release v1.4.0-beta1v1.4.0-beta1

1 files changed, 929 insertions, 0 deletions

diff --git a/internal/crt2/tcl.go b/internal/crt2/tcl.go
new file mode 100644
index 0000000..64f2da7
--- /dev/null
+++ b/internal/crt2/tcl.go
@@ -0,0 +1,929 @@
+// Copyright 2020 The Sqlite Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package crt2 // import "modernc.org/sqlite/internal/crt2"
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+
+	"modernc.org/crt/v3"
+)
+
+// const (
+// 	TCL_GLOBAL_ONLY = 1
+// )
+//
+// var (
+// 	fToken           uint64
+// 	nameOfExecutable string
+// 	objects          = map[uintptr]objectNfo{}
+// 	objectsMu        sync.Mutex
+// )
+//
+// func nextToken() uintptr { return uintptr(atomic.AddUint64(&fToken, 1)) }
+//
+// type objectNfo struct {
+// 	memcheckerNfo
+// 	value interface{}
+// }
+//
+// func addObject(o interface{}) uintptr {
+// 	var v objectNfo
+// 	v.value = o
+// 	v.object = o
+// 	v.pc, v.file, v.line, v.ok = runtime.Caller(1)
+// 	h := nextToken()
+// 	objectsMu.Lock()
+// 	objects[h] = v
+// 	objectsMu.Unlock()
+// 	return h
+// }
+//
+// func getObject(h uintptr) interface{} {
+// 	if h <= 0 {
+// 		panic(todo(""))
+// 	}
+//
+// 	objectsMu.Lock()
+// 	v, ok := objects[h]
+// 	if !ok {
+// 		panic(todo("", h))
+// 	}
+//
+// 	objectsMu.Unlock()
+// 	return v.value
+// }
+//
+// func removeObject(h uintptr) {
+// 	if h <= 0 {
+// 		panic(todo(""))
+// 	}
+//
+// 	objectsMu.Lock()
+// 	if _, ok := objects[h]; !ok {
+// 		panic(todo(""))
+// 	}
+//
+// 	delete(objects, h)
+// 	objectsMu.Unlock()
+// }
+
+func todo(s string, args ...interface{}) string { //TODO-
+	switch {
+	case s == "":
+		s = fmt.Sprintf(strings.Repeat("%v ", len(args)), args...)
+	default:
+		s = fmt.Sprintf(s, args...)
+	}
+	pc, fn, fl, _ := runtime.Caller(1)
+	f := runtime.FuncForPC(pc)
+	var fns string
+	if f != nil {
+		fns = f.Name()
+		if x := strings.LastIndex(fns, "."); x > 0 {
+			fns = fns[x+1:]
+		}
+	}
+	r := fmt.Sprintf("%s:%d:%s: TODOTODO %s", fn, fl, fns, s) //TODOOK
+	fmt.Fprintf(os.Stdout, "%s\n", r)
+	os.Stdout.Sync()
+	return r
+}
+
+func trc(s string, args ...interface{}) string { //TODO-
+	switch {
+	case s == "":
+		s = fmt.Sprintf(strings.Repeat("%v ", len(args)), args...)
+	default:
+		s = fmt.Sprintf(s, args...)
+	}
+	_, fn, fl, _ := runtime.Caller(1)
+	r := fmt.Sprintf("\n%s:%d: TRC %s", fn, fl, s)
+	fmt.Fprintf(os.Stdout, "%s\n", r)
+	os.Stdout.Sync()
+	return r
+}
+
+// int sched_yield(void);
+func Xsched_yield(tls *crt.TLS) int32 {
+	panic(todo(""))
+}
+
+// int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
+func Xpthread_create(tls *crt.TLS, thread, attr, start_routine, arg uintptr) int32 {
+	panic(todo(""))
+}
+
+// int pthread_detach(pthread_t thread);
+func Xpthread_detach(tls *crt.TLS, thread crt.Size_t) int32 {
+	panic(todo(""))
+}
+
+// int ferror(FILE *stream);
+func Xferror(tls *crt.TLS, stream uintptr) int32 {
+	panic(todo(""))
+}
+
+// // int ftruncate(int fd, off_t length);
+// func Xftruncate(tls *crt.TLS, fd int32, length crt.Ssize_t) int32 {
+// 	panic(todo(""))
+// }
+
+// int fstat(int fd, struct stat *statbuf);
+func Xfstat(tls *crt.TLS, fd int32, statbuf uintptr) int32 {
+	panic(todo(""))
+}
+
+// // int rename(const char *oldpath, const char *newpath);
+// func Xrename(tls *crt.TLS, oldpath, newpath uintptr) int32 {
+// 	panic(todo(""))
+// }
+
+// int pthread_mutex_lock(pthread_mutex_t *mutex);
+func Xpthread_mutex_lock(tls *crt.TLS, mutex uintptr) int32 {
+	panic(todo(""))
+}
+
+// int pthread_cond_signal(pthread_cond_t *cond);
+func Xpthread_cond_signal(tls *crt.TLS, cond uintptr) int32 {
+	panic(todo(""))
+}
+
+// int pthread_mutex_unlock(pthread_mutex_t *mutex);
+func Xpthread_mutex_unlock(tls *crt.TLS, mutex uintptr) int32 {
+	panic(todo(""))
+}
+
+// int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
+func Xpthread_mutex_init(tls *crt.TLS, mutex, attr uintptr) int32 {
+	panic(todo(""))
+}
+
+// int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
+func Xpthread_cond_init(tls *crt.TLS, cond, attr uintptr) int32 {
+	panic(todo(""))
+}
+
+// int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
+func Xpthread_cond_wait(tls *crt.TLS, cond, mutex uintptr) int32 {
+	panic(todo(""))
+}
+
+// int pthread_cond_destroy(pthread_cond_t *cond);
+func Xpthread_cond_destroy(tls *crt.TLS, cond uintptr) int32 {
+	panic(todo(""))
+}
+
+// // int stat(const char *pathname, struct stat *statbuf);
+// func Xstat(tls *crt.TLS, pathname, statbuf uintptr) int32 {
+// 	panic(todo(""))
+// }
+//
+// // int lstat(const char *pathname, struct stat *statbuf);
+// func Xlstat(tls *crt.TLS, pathname, statbuf uintptr) int32 {
+// 	panic(todo(""))
+// }
+//
+// // struct dirent *readdir(DIR *dirp);
+// func Xreaddir(tls *crt.TLS, dirp uintptr) uintptr {
+// 	panic(todo(""))
+// }
+
+// int pthread_mutex_destroy(pthread_mutex_t *mutex);
+func Xpthread_mutex_destroy(tls *crt.TLS, mutex uintptr) int32 {
+	panic(todo(""))
+}
+
+// // ============================================================================
+//
+// // void *malloc(size_t size);
+// func Xmalloc(tls *crt.TLS, size crt.Size_t) uintptr {
+// 	p := crt.Xmalloc(tls, size)
+// 	if p != 0 {
+// 		Memcheck.add(p, size)
+// 	}
+// 	return p
+// }
+//
+// // void *calloc(size_t nmemb, size_t size);
+// func Xcalloc(tls *crt.TLS, n, size crt.Size_t) uintptr {
+// 	p := crt.Xcalloc(tls, n, size)
+// 	if p != 0 {
+// 		Memcheck.add(p, n*size)
+// 	}
+// 	return p
+// }
+//
+// // void *realloc(void *ptr, size_t size);
+// func Xrealloc(tls *crt.TLS, ptr uintptr, size crt.Size_t) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // void free(void *ptr);
+// func Xfree(tls *crt.TLS, ptr uintptr) {
+// 	if ptr != 0 {
+// 		Memcheck.remove(ptr)
+// 	}
+// 	crt.Xfree(tls, ptr)
+// }
+//
+// // void abort(void);
+// func Xabort(tls *crt.TLS) {
+// 	Xexit(tls, 1)
+// }
+//
+// // void exit(int status);
+// func Xexit(tls *crt.TLS, status int32) {
+// 	s := Memcheck.Audit()
+// 	//trc("Memcheck.Audit(): %s", s)
+// 	if s != "" && status == 0 {
+// 		status = 1
+// 	}
+// 	fmt.Fprintln(os.Stderr, s)
+// 	os.Stderr.Sync()
+// 	crt.Xexit(tls, status)
+// }
+//
+// func X__builtin_exit(tls *crt.TLS, status int32) { Xexit(tls, status) }
+//
+// // void __assert_fail(const char * assertion, const char * file, unsigned int line, const char * function);
+// func X__assert_fail(tls *crt.TLS, assertion, file uintptr, line uint32, function uintptr) {
+// 	fmt.Fprintf(os.Stderr, "assertion failure: %s:%d.%s: %s\n", crt.GoString(file), line, crt.GoString(function), crt.GoString(assertion))
+// 	os.Stderr.Sync()
+// 	Xexit(tls, 1)
+// }
+//
+// // void __builtin_trap (void)
+// func X__builtin_trap(tls *crt.TLS) {
+// 	fmt.Fprintf(os.Stderr, "%s\ntrap\n", debug.Stack())
+// 	os.Stderr.Sync()
+// 	Xexit(tls, 1)
+// }
+//
+// // void __builtin_unreachable (void)
+// func X__builtin_unreachable(tls *crt.TLS) {
+// 	fmt.Fprintf(os.Stderr, "%s\nunrechable\n", debug.Stack())
+// 	os.Stderr.Sync()
+// 	Xexit(tls, 1)
+// }
+//
+// // ============================================================================
+//
+// // int Tcl_UnregisterChannel(Tcl_Interp *interp, Tcl_Channel chan);
+// func XTcl_UnregisterChannel(tls *crt.TLS, interp, chan1 uintptr) int32 {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_Free(char *ptr);
+// func XTcl_Free(tls *crt.TLS, ptr uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // char * Tcl_Alloc(unsigned int size);
+// func XTcl_Alloc(tls *crt.TLS, size uint32) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // Tcl_Channel Tcl_CreateChannel(const Tcl_ChannelType *typePtr, const char *chanName, ClientData instanceData, int mask);
+// func XTcl_CreateChannel(tls *crt.TLS, typePtr, chanName, instanceData uintptr, mask int32) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // const char * Tcl_GetChannelName(Tcl_Channel chan);
+// func XTcl_GetChannelName(tls *crt.TLS, chan1 uintptr) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // char * Tcl_GetStringFromObj(Tcl_Obj *objPtr, int *lengthPtr);
+// func XTcl_GetStringFromObj(tls *crt.TLS, objPtr, lengthPtr uintptr) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_RegisterChannel(Tcl_Interp *interp, Tcl_Channel chan);
+// func XTcl_RegisterChannel(tls *crt.TLS, interp, chan1 uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_SetResult(Tcl_Interp *interp, char *result, Tcl_FreeProc *freeProc);
+// func XTcl_SetResult(tls *crt.TLS, interp, result, freeProc uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // void TclFreeObj(Tcl_Obj *objPtr);
+// func XTclFreeObj(tls *crt.TLS, objPtr uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_AppendResult(Tcl_Interp *interp, ...);
+// func XTcl_AppendResult(tls *crt.TLS, interp, va uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_BackgroundError(Tcl_Interp *interp);
+// func XTcl_BackgroundError(tls *crt.TLS, interp uintptr) { panic(todo("")) }
+//
+// // Tcl_CreateInterp creates a new interpreter structure and returns a token for
+// // it. The token is required in calls to most other Tcl procedures, such as
+// // Tcl_CreateCommand, Tcl_Eval, and Tcl_DeleteInterp. The token returned by
+// // Tcl_CreateInterp may only be passed to Tcl routines called from the same
+// // thread as the original Tcl_CreateInterp call. It is not safe for multiple
+// // threads to pass the same token to Tcl's routines. The new interpreter is
+// // initialized with the built-in Tcl commands and with standard variables like
+// // tcl_platform and env. To bind in additional commands, call
+// // Tcl_CreateCommand, and to create additional variables, call Tcl_SetVar.
+// //
+// // Tcl_Interp * Tcl_CreateInterp(void);
+// func XTcl_CreateInterp(tls *crt.TLS) uintptr {
+// 	ctx := tee.NewContext("", false)
+// 	if err := registerBuiltinCommands(ctx); err != nil {
+// 		panic(todo("", err))
+// 	}
+//
+// 	return addObject(ctx)
+// }
+//
+// // Tcl_CreateObjCommand defines a new command in interp and associates it with
+// // procedure proc such that whenever name is invoked as a Tcl command (e.g.,
+// // via a call to Tcl_EvalObjEx) the Tcl interpreter will call proc to process
+// // the command.
+// //
+// // Tcl_CreateObjCommand deletes any existing command name already associated
+// // with the interpreter (however see below for an exception where the existing
+// // command is not deleted). It returns a token that may be used to refer to the
+// // command in subsequent calls to Tcl_GetCommandName. If name contains any ::
+// // namespace qualifiers, then the command is added to the specified namespace;
+// // otherwise the command is added to the global namespace. If
+// // Tcl_CreateObjCommand is called for an interpreter that is in the process of
+// // being deleted, then it does not create a new command and it returns NULL.
+// // proc should have arguments and result that match the type Tcl_ObjCmdProc:
+// //
+// //	typedef int Tcl_ObjCmdProc(
+// //	        ClientData clientData,
+// //	        Tcl_Interp *interp,
+// //	        int objc,
+// //	        Tcl_Obj *const objv[]);
+// //
+// // When proc is invoked, the clientData and interp parameters will be copies of
+// // the clientData and interp arguments given to Tcl_CreateObjCommand.
+// // Typically, clientData points to an application-specific data structure that
+// // describes what to do when the command procedure is invoked. Objc and objv
+// // describe the arguments to the command, objc giving the number of argument
+// // values (including the command name) and objv giving the values of the
+// // arguments. The objv array will contain objc values, pointing to the argument
+// // values. Unlike argv[argv] used in a string-based command procedure,
+// // objv[objc] will not contain NULL.
+// //
+// // Additionally, when proc is invoked, it must not modify the contents of the
+// // objv array by assigning new pointer values to any element of the array (for
+// // example, objv[2] = NULL) because this will cause memory to be lost and the
+// // runtime stack to be corrupted. The const in the declaration of objv will
+// // cause ANSI-compliant compilers to report any such attempted assignment as an
+// // error. However, it is acceptable to modify the internal representation of
+// // any individual value argument. For instance, the user may call
+// // Tcl_GetIntFromObj on objv[2] to obtain the integer representation of that
+// // value; that call may change the type of the value that objv[2] points at,
+// // but will not change where objv[2] points.
+// //
+// // proc must return an integer code that is either TCL_OK, TCL_ERROR,
+// // TCL_RETURN, TCL_BREAK, or TCL_CONTINUE. See the Tcl overview man page for
+// // details on what these codes mean. Most normal commands will only return
+// // TCL_OK or TCL_ERROR. In addition, if proc needs to return a non-empty
+// // result, it can call Tcl_SetObjResult to set the interpreter's result. In the
+// // case of a TCL_OK return code this gives the result of the command, and in
+// // the case of TCL_ERROR this gives an error message. Before invoking a command
+// // procedure, Tcl_EvalObjEx sets interpreter's result to point to a value
+// // representing an empty string, so simple commands can return an empty result
+// // by doing nothing at all.
+// //
+// // The contents of the objv array belong to Tcl and are not guaranteed to
+// // persist once proc returns: proc should not modify them. Call
+// // Tcl_SetObjResult if you want to return something from the objv array.
+// //
+// // Ordinarily, Tcl_CreateObjCommand deletes any existing command name already
+// // associated with the interpreter. However, if the existing command was
+// // created by a previous call to Tcl_CreateCommand, Tcl_CreateObjCommand does
+// // not delete the command but instead arranges for the Tcl interpreter to call
+// // the Tcl_ObjCmdProc proc in the future. The old string-based Tcl_CmdProc
+// // associated with the command is retained and its address can be obtained by
+// // subsequent Tcl_GetCommandInfo calls. This is done for backwards
+// // compatibility.
+// //
+// // DeleteProc will be invoked when (if) name is deleted. This can occur through
+// // a call to Tcl_DeleteCommand, Tcl_DeleteCommandFromToken, or
+// // Tcl_DeleteInterp, or by replacing name in another call to
+// // Tcl_CreateObjCommand. DeleteProc is invoked before the command is deleted,
+// // and gives the application an opportunity to release any structures
+// // associated with the command. DeleteProc should have arguments and result
+// // that match the type Tcl_CmdDeleteProc:
+// //
+// //	typedef void Tcl_CmdDeleteProc(
+// //	        ClientData clientData);
+// //
+// // The clientData argument will be the same as the clientData argument passed
+// // to Tcl_CreateObjCommand.
+// //
+// // Tcl_Command Tcl_CreateObjCommand(Tcl_Interp *interp, const char *cmdName, Tcl_ObjCmdProc *proc, ClientData clientData, Tcl_CmdDeleteProc *deleteProc);
+// func XTcl_CreateObjCommand(tls *crt.TLS, interp, cmdName0, proc, clientData, deleteProc uintptr) uintptr {
+// 	ctx := getObject(interp).(*tee.Context)
+// 	if ctx.BeingDeleted {
+// 		return 0
+// 	}
+//
+// 	cmdName := crt.GoString(cmdName0)
+// 	cmd, rc := ctx.Proc(
+// 		tee.NewString(cmdName), tee.NewNoValue(), tee.NewNoValue(),
+// 		func(ctx *tee.Context, values ...tee.Value) tee.ReturnCode {
+// 			panic(todo(""))
+// 		},
+// 		func(cmd *tee.Command) error {
+// 			panic(todo(""))
+// 		},
+// 		clientData,
+// 	)
+// 	if rc != tee.Ok {
+// 		panic(todo(""))
+// 	}
+//
+// 	return addObject(cmd)
+// }
+//
+// // char * Tcl_DStringAppend(Tcl_DString *dsPtr, const char *bytes, int length);
+// func XTcl_DStringAppend(tls *crt.TLS, dsPtr, bytes uintptr, length int32) uintptr { panic(todo("")) }
+//
+// // char * Tcl_DStringAppendElement(Tcl_DString *dsPtr, const char *element);
+// func XTcl_DStringAppendElement(tls *crt.TLS, dsPtr, element uintptr) uintptr { panic(todo("")) }
+//
+// // void Tcl_DStringFree(Tcl_DString *dsPtr);
+// func XTcl_DStringFree(tls *crt.TLS, dsPtr uintptr) { panic(todo("")) }
+//
+// // void Tcl_DStringInit(Tcl_DString *dsPtr);
+// func XTcl_DStringInit(tls *crt.TLS, dsPtr uintptr) { panic(todo("")) }
+//
+// // int Tcl_DeleteCommand(Tcl_Interp *interp, const char *cmdName);
+// func XTcl_DeleteCommand(tls *crt.TLS, interp, cmdName uintptr) int32 { panic(todo("")) }
+//
+// // Tcl_Obj * Tcl_DuplicateObj(Tcl_Obj *objPtr);
+// func XTcl_DuplicateObj(tls *crt.TLS, objPtr uintptr) uintptr { panic(todo("")) }
+//
+// // int Tcl_Eval(Tcl_Interp *interp, const char *script);
+// func XTcl_Eval(tls *crt.TLS, interp, script uintptr) int32 { panic(todo("")) }
+//
+// // int Tcl_EvalObjEx(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags);
+// func XTcl_EvalObjEx(tls *crt.TLS, interp, objPtr uintptr, flags int32) int32 { panic(todo("")) }
+//
+// // void Tcl_FindExecutable(const char *argv0);
+// func XTcl_FindExecutable(tls *crt.TLS, argv00 uintptr) {
+// 	argv0 := crt.GoString(argv00)
+// 	if filepath.IsAbs(argv0) {
+// 		nameOfExecutable = argv0
+// 		return
+// 	}
+//
+// 	argv0, err := exec.LookPath(argv0)
+// 	if err != nil {
+// 		return
+// 	}
+//
+// 	if argv0, err = filepath.Abs(argv0); err != nil {
+// 		return
+// 	}
+//
+// 	nameOfExecutable = argv0
+// }
+//
+// // int Tcl_GetBooleanFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int *boolPtr);
+// func XTcl_GetBooleanFromObj(tls *crt.TLS, interp, objPtr, boolPtr uintptr) int32 { panic(todo("")) }
+//
+// // unsigned char * Tcl_GetByteArrayFromObj(Tcl_Obj *objPtr, int *lengthPtr);
+// func XTcl_GetByteArrayFromObj(tls *crt.TLS, objPtr, lengthPtr uintptr) uintptr { panic(todo("")) }
+//
+// // int Tcl_GetCharLength(Tcl_Obj *objPtr);
+// func XTcl_GetCharLength(tls *crt.TLS, objPtr uintptr) int32 { panic(todo("")) }
+//
+// // int Tcl_GetDoubleFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, double *doublePtr);
+// func XTcl_GetDoubleFromObj(tls *crt.TLS, interp, objPtr, doublePtr uintptr) int32 { panic(todo("")) }
+//
+// // int Tcl_GetIndexFromObjStruct(Tcl_Interp *interp, Tcl_Obj *objPtr, const void *tablePtr, int offset, const char *msg, int flags, int *indexPtr);
+// func XTcl_GetIndexFromObjStruct(tls *crt.TLS, interp, objPtr, tablePtr uintptr, offset int32, msg uintptr, flags int32, indexPtr uintptr) int32 {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_GetIntFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int *intPtr);
+// func XTcl_GetIntFromObj(tls *crt.TLS, interp, objPtr, intPtr uintptr) int32 { panic(todo("")) }
+//
+// // Tcl_Obj * Tcl_GetObjResult(Tcl_Interp *interp);
+// func XTcl_GetObjResult(tls *crt.TLS, interp uintptr) uintptr { panic(todo("")) }
+//
+// // char * Tcl_GetString(Tcl_Obj *objPtr);
+// func XTcl_GetString(tls *crt.TLS, objPtr uintptr) uintptr { panic(todo("")) }
+//
+// // const char * Tcl_GetStringResult(Tcl_Interp *interp);
+// func XTcl_GetStringResult(tls *crt.TLS, interp uintptr) uintptr { panic(todo("")) }
+//
+// // const char * Tcl_GetVar2(Tcl_Interp *interp, const char *part1, const char *part2, int flags);
+// func XTcl_GetVar2(tls *crt.TLS, interp, part1, part2 uintptr, flags int32) uintptr { panic(todo("")) }
+//
+// // Tcl_Obj * Tcl_GetVar2Ex(Tcl_Interp *interp, const char *part1, const char *part2, int flags);
+// func XTcl_GetVar2Ex(tls *crt.TLS, interp, part1, part2 uintptr, flags int32) uintptr { panic(todo("")) }
+//
+// // void Tcl_GetVersion(int *major, int *minor, int *patchLevel, int *type);
+// func XTcl_GetVersion(tls *crt.TLS, major, minor, patchLevel, type1 uintptr) { panic(todo("")) }
+//
+// // int Tcl_GetWideIntFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, Tcl_WideInt *widePtr);
+// func XTcl_GetWideIntFromObj(tls *crt.TLS, interp, objPtr, widePtr uintptr) int32 { panic(todo("")) }
+//
+// // int Tcl_GlobalEval(Tcl_Interp *interp, const char *command);
+// func XTcl_GlobalEval(tls *crt.TLS, interp, command uintptr) int32 { panic(todo("")) }
+//
+// //  int Tcl_ListObjAppendElement(Tcl_Interp *interp, Tcl_Obj *listPtr, Tcl_Obj *objPtr);
+// func XTcl_ListObjAppendElement(tls *crt.TLS, interp, listPtr, objPtr uintptr) int32 { panic(todo("")) }
+//
+// // int Tcl_ListObjGetElements(Tcl_Interp *interp, Tcl_Obj *listPtr, int *objcPtr, Tcl_Obj ***objvPtr);
+// func XTcl_ListObjGetElements(tls *crt.TLS, interp, listPtr, objcPtr, objvPtr uintptr) int32 {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_ListObjIndex(Tcl_Interp *interp, Tcl_Obj *listPtr, int index, Tcl_Obj **objPtrPtr);
+// func XTcl_ListObjIndex(tls *crt.TLS, interp, listPtr uintptr, index int32, objPtrPtr uintptr) int32 {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_ListObjLength(Tcl_Interp *interp, Tcl_Obj *listPtr, int *lengthPtr);
+// func XTcl_ListObjLength(tls *crt.TLS, interp, listPtr, lengthPtr uintptr) int32 { panic(todo("")) }
+//
+// // void Tcl_NRAddCallback(Tcl_Interp *interp, Tcl_NRPostProc *postProcPtr, ClientData data0, ClientData data1, ClientData data2, ClientData data3);
+// func XTcl_NRAddCallback(tls *crt.TLS, interp, postProcPtr, data0, data1, data2, data3 uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_NRCallObjProc(Tcl_Interp *interp, Tcl_ObjCmdProc *objProc, ClientData clientData, int objc, Tcl_Obj *const objv[]);
+// func XTcl_NRCallObjProc(tls *crt.TLS, interp, objProc, clientData uintptr, objc int32, objv uintptr) int32 {
+// 	panic(todo(""))
+// }
+//
+// // Tcl_Command Tcl_NRCreateCommand(Tcl_Interp *interp, const char *cmdName, Tcl_ObjCmdProc *proc, Tcl_ObjCmdProc *nreProc, ClientData clientData, Tcl_CmdDeleteProc *deleteProc);
+// func XTcl_NRCreateCommand(tls *crt.TLS, interp, cmdName, proc, nreProc, clientData, deleteProc uintptr) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_NREvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags);
+// func XTcl_NREvalObj(tls *crt.TLS, interp, objPtr uintptr, flags int32) int32 { panic(todo("")) }
+//
+// // Tcl_Obj * Tcl_NewByteArrayObj(const unsigned char *bytes, int length);
+// func XTcl_NewByteArrayObj(tls *crt.TLS, bytes uintptr, length int32) uintptr { panic(todo("")) }
+//
+// // Tcl_Obj * Tcl_NewDoubleObj(double doubleValue);
+// func XTcl_NewDoubleObj(tls *crt.TLS, doubleValue float64) uintptr { panic(todo("")) }
+//
+// // Tcl_Obj * Tcl_NewIntObj(int intValue);
+// func XTcl_NewIntObj(tls *crt.TLS, intValue int32) uintptr { panic(todo("")) }
+//
+// // Tcl_Obj * Tcl_NewListObj(int objc, Tcl_Obj *const objv[]);
+// func XTcl_NewListObj(tls *crt.TLS, objc int32, objv uintptr) uintptr { panic(todo("")) }
+//
+// // Tcl_Obj * Tcl_NewObj(void);
+// func XTcl_NewObj(tls *crt.TLS) uintptr { panic(todo("")) }
+//
+// // Tcl_Obj * Tcl_NewStringObj(const char *bytes, int length);
+// func XTcl_NewStringObj(tls *crt.TLS, bytes uintptr, length int32) uintptr { panic(todo("")) }
+//
+// // Tcl_Obj * Tcl_NewWideIntObj(Tcl_WideInt wideValue);
+// func XTcl_NewWideIntObj(tls *crt.TLS, wideValue crt.Intptr) uintptr { panic(todo("")) }
+//
+// // Tcl_Obj * Tcl_ObjSetVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, Tcl_Obj *newValuePtr, int flags);
+// func XTcl_ObjSetVar2(tls *crt.TLS, interp, part1, part2, newValuePtr uintptr, flags int32) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_PkgProvideEx(Tcl_Interp *interp, const char *name, const char *version, const void *clientData);
+// func XTcl_PkgProvideEx(tls *crt.TLS, interp, name0, version0, clientData uintptr) int32 {
+// 	name := crt.GoString(name0)
+// 	version := crt.GoString(version0)
+// 	switch name {
+// 	case "sqlite3":
+// 		if version != sqlite3.SQLITE_VERSION {
+// 			panic(todo("%q %q", name, version))
+// 		}
+// 	default:
+// 		panic(todo("%q %q", name, version))
+// 	}
+//
+// 	return int32(tee.Ok)
+// }
+//
+// // void Tcl_ResetResult(Tcl_Interp *interp);
+// func XTcl_ResetResult(tls *crt.TLS, interp uintptr) { panic(todo("")) }
+//
+// // void Tcl_SetIntObj(Tcl_Obj *objPtr, int intValue);
+// func XTcl_SetIntObj(tls *crt.TLS, objPtr uintptr, intValue int32) { panic(todo("")) }
+//
+// // void Tcl_SetObjResult(Tcl_Interp *interp, Tcl_Obj *resultObjPtr);
+// func XTcl_SetObjResult(tls *crt.TLS, interp, resultObjPtr uintptr) { panic(todo("")) }
+//
+// // Tcl_SetSystemEncoding sets the default encoding that should be used whenever
+// // the user passes a NULL value for the encoding argument to any of the other
+// // encoding functions. If name is NULL, the system encoding is reset to the
+// // default system encoding, binary. If the name did not refer to any known or
+// // loadable encoding, TCL_ERROR is returned and an error message is left in
+// // interp. Otherwise, this procedure increments the reference count of the new
+// // system encoding, decrements the reference count of the old system encoding,
+// // and returns TCL_OK.
+// //
+// // int Tcl_SetSystemEncoding(Tcl_Interp *interp, const char *name);
+// func XTcl_SetSystemEncoding(tls *crt.TLS, interp, name0 uintptr) int32 {
+// 	name := crt.GoString(name0)
+// 	if interp != 0 {
+// 		panic(todo(""))
+// 	}
+//
+// 	if name != "utf-8" {
+// 		panic(todo(""))
+// 	}
+//
+// 	return int32(tee.Ok)
+// }
+//
+// // Tcl_SetVar2Ex, Tcl_SetVar, Tcl_SetVar2, and Tcl_ObjSetVar2 will create a new
+// // variable or modify an existing one. These procedures set the given variable
+// // to the value given by newValuePtr or newValue and return a pointer to the
+// // variable's new value, which is stored in Tcl's variable structure.
+// // Tcl_SetVar2Ex and Tcl_ObjSetVar2 take the new value as a Tcl_Obj and return
+// // a pointer to a Tcl_Obj. Tcl_SetVar and Tcl_SetVar2 take the new value as a
+// // string and return a string; they are usually less efficient than
+// // Tcl_ObjSetVar2. Note that the return value may be different than the
+// // newValuePtr or newValue argument, due to modifications made by write traces.
+// // If an error occurs in setting the variable (e.g. an array variable is
+// // referenced without giving an index into the array) NULL is returned and an
+// // error message is left in interp's result if the TCL_LEAVE_ERR_MSG flag bit
+// // is set.
+// //
+// // The name of a variable may be specified to these procedures in four ways:
+// //
+// // 1. If Tcl_SetVar, Tcl_GetVar, or Tcl_UnsetVar is invoked, the variable name
+// // is given as a single string, varName. If varName contains an open
+// // parenthesis and ends with a close parenthesis, then the value between the
+// // parentheses is treated as an index (which can have any string value) and the
+// // characters before the first open parenthesis are treated as the name of an
+// // array variable. If varName does not have parentheses as described above,
+// // then the entire string is treated as the name of a scalar variable.
+// //
+// // 2. If the name1 and name2 arguments are provided and name2 is non-NULL, then
+// // an array element is specified and the array name and index have already been
+// // separated by the caller: name1 contains the name and name2 contains the
+// // index. An error is generated if name1 contains an open parenthesis and ends
+// // with a close parenthesis (array element) and name2 is non-NULL.
+// //
+// // 3. If name2 is NULL, name1 is treated just like varName in case [1] above
+// // (it can be either a scalar or an array element variable name).
+// //
+// // The flags argument may be used to specify any of several options to the
+// // procedures. It consists of an OR-ed combination of the following bits.
+// //
+// //	TCL_GLOBAL_ONLY
+// //
+// // Under normal circumstances the procedures look up variables as follows. If a
+// // procedure call is active in interp, the variable is looked up at the current
+// // level of procedure call. Otherwise, the variable is looked up first in the
+// // current namespace, then in the global namespace. However, if this bit is set
+// // in flags then the variable is looked up only in the global namespace even if
+// // there is a procedure call active. If both TCL_GLOBAL_ONLY and
+// // TCL_NAMESPACE_ONLY are given, TCL_GLOBAL_ONLY is ignored.
+// //
+// //	TCL_NAMESPACE_ONLY
+// //
+// // If this bit is set in flags then the variable is looked up only in the
+// // current namespace; if a procedure is active its variables are ignored, and
+// // the global namespace is also ignored unless it is the current namespace.
+// //
+// //	TCL_LEAVE_ERR_MSG
+// //
+// // If an error is returned and this bit is set in flags, then an error message
+// // will be left in the interpreter's result, where it can be retrieved with
+// // Tcl_GetObjResult or Tcl_GetStringResult. If this flag bit is not set then no
+// // error message is left and the interpreter's result will not be modified.
+// //
+// //	TCL_APPEND_VALUE
+// // If this bit is set then newValuePtr or newValue is appended to the current
+// // value instead of replacing it. If the variable is currently undefined, then
+// // the bit is ignored. This bit is only used by the Tcl_Set* procedures.
+// //
+// //	TCL_LIST_ELEMENT
+// //
+// // If this bit is set, then newValue is converted to a valid Tcl list element
+// // before setting (or appending to) the variable. A separator space is appended
+// // before the new list element unless the list element is going to be the first
+// // element in a list or sublist (i.e. the variable's current value is empty, or
+// // contains the single character “{”, or ends in “ }”). When appending, the
+// // original value of the variable must also be a valid list, so that the
+// // operation is the appending of a new list element onto a list.
+// //
+// // const char * Tcl_SetVar2(Tcl_Interp *interp, const char *part1, const char *part2, const char *newValue, int flags);
+// func XTcl_SetVar2(tls *crt.TLS, interp, part10, part20, newValue0 uintptr, flags int32) {
+// 	ctx := getObject(interp).(*tee.Context)
+// 	part1 := crt.GoString(part10)
+// 	part2 := crt.GoString(part20)
+// 	newValue := crt.GoString(newValue0)
+// 	if part20 != 0 && (strings.Contains(part1, "(") || strings.Contains(part1, ")")) {
+// 		panic(todo(""))
+// 	}
+//
+// 	name := part1
+// 	if part2 != "" {
+// 		name = fmt.Sprintf("%s(%s)", part1, part2)
+// 	}
+// 	switch flags {
+// 	case TCL_GLOBAL_ONLY:
+// 		_ = ctx
+// 		panic(todo("%q %q %q %q %#x(%[5]v)", part1, part2, name, newValue, flags))
+// 	default:
+// 		panic(todo("%q %q %q %q %#x(%[5]v)", part1, part2, name, newValue, flags))
+// 	}
+// }
+//
+// // void Tcl_SetWideIntObj(Tcl_Obj *objPtr, Tcl_WideInt wideValue);
+// func XTcl_SetWideIntObj(tls *crt.TLS, objPtr uintptr, wideValue crt.Intptr) { panic(todo("")) }
+//
+// // char * Tcl_TranslateFileName(Tcl_Interp *interp, const char *name, Tcl_DString *bufferPtr);
+// func XTcl_TranslateFileName(tls *crt.TLS, interp, name, bufferPtr uintptr) uintptr { panic(todo("")) }
+//
+// // int Tcl_UnsetVar2(Tcl_Interp *interp, const char *part1, const char *part2, int flags);
+// func XTcl_UnsetVar2(tls *crt.TLS, interp, part1, part2 uintptr, flags int32) { panic(todo("")) }
+//
+// // int Tcl_VarEval(Tcl_Interp *interp, ...);
+// func XTcl_VarEval(tls *crt.TLS, interp, va uintptr) int32 { panic(todo("")) }
+//
+// // void Tcl_WrongNumArgs(Tcl_Interp *interp, int objc, Tcl_Obj *const objv[], const char *message);
+// func XTcl_WrongNumArgs(tls *crt.TLS, interp uintptr, objc int32, objv, message uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_GetCommandInfo(Tcl_Interp *interp, const char *cmdName, Tcl_CmdInfo *infoPtr);
+// func XTcl_GetCommandInfo(tls *crt.TLS, interp, cmdName, infoPtr uintptr) int32 {
+// 	panic(todo(""))
+// }
+//
+// // Tcl_Command Tcl_CreateCommand(Tcl_Interp *interp, const char *cmdName, Tcl_CmdProc *proc, ClientData clientData, Tcl_CmdDeleteProc *deleteProc);
+// func XTcl_CreateCommand(tls *crt.TLS, interp, cmdName, proc, clentData, deleteProc uintptr) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_LinkVar(Tcl_Interp *interp, const char *varName, char *addr, int type);
+// func XTcl_LinkVar(tls *crt.TLS, interp, varName, addr uintptr, type1 int32) int32 {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_AppendElement(Tcl_Interp *interp, const char *element);
+// func XTcl_AppendElement(tls *crt.TLS, interp, element uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_GetInt(Tcl_Interp *interp, const char *src, int *intPtr);
+// func XTcl_GetInt(tls *crt.TLS, interp, src, intPtr uintptr) int32 {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_GetDouble(Tcl_Interp *interp, const char *src, double *doublePtr);
+// func XTcl_GetDouble(tls *crt.TLS, interp, src, doublePtr uintptr) int32 {
+// 	panic(todo(""))
+// }
+//
+// // Tcl_Channel Tcl_GetChannel(Tcl_Interp *interp, const char *chanName, int *modePtr);
+// func XTcl_GetChannel(tls *crt.TLS, interp, chanName, modePtr uintptr) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_Flush(Tcl_Channel chan);
+// func XTcl_Flush(tls *crt.TLS, chan1 uintptr) int32 {
+// 	panic(todo(""))
+// }
+//
+// // Tcl_WideInt Tcl_Seek(Tcl_Channel chan, Tcl_WideInt offset, int mode);
+// func XTcl_Seek(tls *crt.TLS, chan1 uintptr, offset crt.Intptr, mode int32) crt.Intptr {
+// 	panic(todo(""))
+// }
+//
+// // ClientData Tcl_GetChannelInstanceData(Tcl_Channel chan);
+// func XTcl_GetChannelInstanceData(tls *crt.TLS, chan1 uintptr) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_EvalEx(Tcl_Interp *interp, const char *script, int numBytes, int flags);
+// func XTcl_EvalEx(tls *crt.TLS, interp, script uintptr, numBytes, flags int32) int32 {
+// 	panic(todo(""))
+// }
+//
+// // __attribute__ ((noreturn)) void Tcl_Panic(const char *format, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
+// func XTcl_Panic(tls *crt.TLS, format, va uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_GetBoolean(Tcl_Interp *interp, const char *src, int *boolPtr);
+// func XTcl_GetBoolean(tls *crt.TLS, interp, src, boolPtr uintptr) int32 {
+// 	panic(todo(""))
+// }
+//
+// // char * Tcl_AttemptAlloc(unsigned int size);
+// func XTcl_AttemptAlloc(tls *crt.TLS, size uint32) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // char * Tcl_AttemptRealloc(char *ptr, unsigned int size);
+// func XTcl_AttemptRealloc(tls *crt.TLS, ptr uintptr, size uint32) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_UtfToLower(char *src);
+// func XTcl_UtfToLower(tls *crt.TLS, src uintptr) int32 {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_AppendStringsToObj(Tcl_Obj *objPtr, ...);
+// func XTcl_AppendStringsToObj(tls *crt.TLS, objPtr, va uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // Tcl_HashEntry * Tcl_FirstHashEntry(Tcl_HashTable *tablePtr, Tcl_HashSearch *searchPtr);
+// func XTcl_FirstHashEntry(tls *crt.TLS, tablePtr, searchPtr uintptr) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // Tcl_HashEntry * Tcl_NextHashEntry(Tcl_HashSearch *searchPtr);
+// func XTcl_NextHashEntry(tls *crt.TLS, searchPtr uintptr) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_DeleteHashTable(Tcl_HashTable *tablePtr);
+// func XTcl_DeleteHashTable(tls *crt.TLS, tablePtr uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_InitHashTable(Tcl_HashTable *tablePtr, int keyType);
+// func XTcl_InitHashTable(tls *crt.TLS, tablePtr uintptr, keyType int32) {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_SetCommandInfo(Tcl_Interp *interp, const char *cmdName, const Tcl_CmdInfo *infoPtr);
+// func XTcl_SetCommandInfo(tls *crt.TLS, interp, cmdName, infoPtr uintptr) int32 {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_AppendObjToObj(Tcl_Obj *objPtr, Tcl_Obj *appendObjPtr);
+// func XTcl_AppendObjToObj(tls *crt.TLS, objPtr, appendObjPtr uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // Tcl_Obj * Tcl_ObjGetVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, int flags);
+// func XTcl_ObjGetVar2(tls *crt.TLS, interp, part1Ptr, part2Ptr uintptr, flags int32) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_ThreadQueueEvent(Tcl_ThreadId threadId, Tcl_Event *evPtr, Tcl_QueuePosition position);
+// func XTcl_ThreadQueueEvent(tls *crt.TLS, threadId, evPtr uintptr, position uint32) {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_ThreadAlert(Tcl_ThreadId threadId);
+// func XTcl_ThreadAlert(tls *crt.TLS, threadId uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_DeleteInterp(Tcl_Interp *interp);
+// func XTcl_DeleteInterp(tls *crt.TLS, interp uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_DoOneEvent(int flags);
+// func XTcl_DoOneEvent(tls *crt.TLS, flags int32) int32 {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_ExitThread(int status);
+// func XTcl_ExitThread(tls *crt.TLS, status int32) {
+// 	panic(todo(""))
+// }
+//
+// // Tcl_ThreadId Tcl_GetCurrentThread(void);
+// func XTcl_GetCurrentThread(tls *crt.TLS) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // int Tcl_CreateThread(Tcl_ThreadId *idPtr, Tcl_ThreadCreateProc *proc, ClientData clientData, int stackSize, int flags);
+// func XTcl_CreateThread(tls *crt.TLS, idPtr, proc, clientData uintptr, stackSize, flags int32) int32 {
+// 	panic(todo(""))
+// }
+//
+// // void Tcl_GetTime(Tcl_Time *timeBuf);
+// func XTcl_GetTime(tls *crt.TLS, timeBuf uintptr) {
+// 	panic(todo(""))
+// }
+//
+// // Tcl_Interp * Tcl_GetSlave(Tcl_Interp *interp, const char *slaveName);
+// func XTcl_GetSlave(tls *crt.TLS, interp, slaveName uintptr) uintptr {
+// 	panic(todo(""))
+// }
+//
+// // ============================================================================