diff options
Diffstat (limited to 'internal/crt2')
| -rw-r--r-- | internal/crt2/capi_linux_amd64.go | 141 | ||||
| -rw-r--r-- | internal/crt2/crt2.go | 130 | ||||
| -rw-r--r-- | internal/crt2/tcl.go | 929 |
3 files changed, 145 insertions, 1055 deletions
diff --git a/internal/crt2/capi_linux_amd64.go b/internal/crt2/capi_linux_amd64.go index 4f81933..27b0039 100644 --- a/internal/crt2/capi_linux_amd64.go +++ b/internal/crt2/capi_linux_amd64.go @@ -5,130 +5,19 @@ package crt2 // import "modernc.org/sqlite/internal/crt2" var CAPI = map[string]struct{}{ - "ferror": {}, - "fstat": {}, - // "ftruncate": {}, - // "lstat": {}, - "pthread_cond_destroy": {}, - "pthread_cond_init": {}, - "pthread_cond_signal": {}, - "pthread_cond_wait": {}, - "pthread_create": {}, - "pthread_detach": {}, - "pthread_mutex_destroy": {}, - "pthread_mutex_init": {}, - "pthread_mutex_lock": {}, - "pthread_mutex_unlock": {}, - // "readdir": {}, - // "rename": {}, - "sched_yield": {}, - // "stat": {}, - // - // "__assert_fail": {}, - // "__builtin_exit": {}, - // "__builtin_trap": {}, - // "__builtin_unreachable": {}, - // "abort": {}, - // "calloc": {}, - // "exit": {}, - // "free": {}, - // "malloc": {}, - // "realloc": {}, - // - // "TclFreeObj": {}, - // "Tcl_Alloc": {}, - // "Tcl_AppendElement": {}, - // "Tcl_AppendObjToObj": {}, - // "Tcl_AppendResult": {}, - // "Tcl_AppendStringsToObj": {}, - // "Tcl_AttemptAlloc": {}, - // "Tcl_AttemptRealloc": {}, - // "Tcl_BackgroundError": {}, - // "Tcl_CreateChannel": {}, - // "Tcl_CreateCommand": {}, - // "Tcl_CreateInterp": {}, - // "Tcl_CreateObjCommand": {}, - // "Tcl_CreateThread": {}, - // "Tcl_DStringAppend": {}, - // "Tcl_DStringAppendElement": {}, - // "Tcl_DStringFree": {}, - // "Tcl_DStringInit": {}, - // "Tcl_DeleteCommand": {}, - // "Tcl_DeleteHashTable": {}, - // "Tcl_DeleteInterp": {}, - // "Tcl_DoOneEvent": {}, - // "Tcl_DuplicateObj": {}, - // "Tcl_Eval": {}, - // "Tcl_EvalEx": {}, - // "Tcl_EvalObjEx": {}, - // "Tcl_ExitThread": {}, - // "Tcl_FindExecutable": {}, - // "Tcl_FirstHashEntry": {}, - // "Tcl_Flush": {}, - // "Tcl_Free": {}, - // "Tcl_GetBoolean": {}, - // "Tcl_GetBooleanFromObj": {}, - // "Tcl_GetByteArrayFromObj": {}, - // "Tcl_GetChannel": {}, - // "Tcl_GetChannelInstanceData": {}, - // "Tcl_GetChannelName": {}, - // "Tcl_GetCharLength": {}, - // "Tcl_GetCommandInfo": {}, - // "Tcl_GetCurrentThread": {}, - // "Tcl_GetDouble": {}, - // "Tcl_GetDoubleFromObj": {}, - // "Tcl_GetIndexFromObjStruct": {}, - // "Tcl_GetInt": {}, - // "Tcl_GetIntFromObj": {}, - // "Tcl_GetObjResult": {}, - // "Tcl_GetSlave": {}, - // "Tcl_GetString": {}, - // "Tcl_GetStringFromObj": {}, - // "Tcl_GetStringResult": {}, - // "Tcl_GetTime": {}, - // "Tcl_GetVar2": {}, - // "Tcl_GetVar2Ex": {}, - // "Tcl_GetVersion": {}, - // "Tcl_GetWideIntFromObj": {}, - // "Tcl_GlobalEval": {}, - // "Tcl_InitHashTable": {}, - // "Tcl_LinkVar": {}, - // "Tcl_ListObjAppendElement": {}, - // "Tcl_ListObjGetElements": {}, - // "Tcl_ListObjIndex": {}, - // "Tcl_ListObjLength": {}, - // "Tcl_NRAddCallback": {}, - // "Tcl_NRCallObjProc": {}, - // "Tcl_NRCreateCommand": {}, - // "Tcl_NREvalObj": {}, - // "Tcl_NewByteArrayObj": {}, - // "Tcl_NewDoubleObj": {}, - // "Tcl_NewIntObj": {}, - // "Tcl_NewListObj": {}, - // "Tcl_NewObj": {}, - // "Tcl_NewStringObj": {}, - // "Tcl_NewWideIntObj": {}, - // "Tcl_NextHashEntry": {}, - // "Tcl_ObjGetVar2": {}, - // "Tcl_ObjSetVar2": {}, - // "Tcl_Panic": {}, - // "Tcl_PkgProvideEx": {}, - // "Tcl_RegisterChannel": {}, - // "Tcl_ResetResult": {}, - // "Tcl_Seek": {}, - // "Tcl_SetCommandInfo": {}, - // "Tcl_SetIntObj": {}, - // "Tcl_SetObjResult": {}, - // "Tcl_SetResult": {}, - // "Tcl_SetSystemEncoding": {}, - // "Tcl_SetVar2": {}, - // "Tcl_SetWideIntObj": {}, - // "Tcl_ThreadAlert": {}, - // "Tcl_ThreadQueueEvent": {}, - // "Tcl_TranslateFileName": {}, - // "Tcl_UnregisterChannel": {}, - // "Tcl_UnsetVar2": {}, - // "Tcl_UtfToLower": {}, - // "Tcl_VarEval": {}, - // "Tcl_WrongNumArgs": {}, + "ferror": {}, + "fstat": {}, + "pthread_cond_broadcast": {}, + "pthread_cond_destroy": {}, + "pthread_cond_init": {}, + "pthread_cond_signal": {}, + "pthread_cond_wait": {}, + "pthread_create": {}, + "pthread_detach": {}, + "pthread_mutex_destroy": {}, + "pthread_mutex_init": {}, + "pthread_mutex_lock": {}, + "pthread_mutex_trylock": {}, + "pthread_mutex_unlock": {}, + "sched_yield": {}, } diff --git a/internal/crt2/crt2.go b/internal/crt2/crt2.go new file mode 100644 index 0000000..bffe76b --- /dev/null +++ b/internal/crt2/crt2.go @@ -0,0 +1,130 @@ +// 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" +) + +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 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 pthread_mutex_destroy(pthread_mutex_t *mutex); +func Xpthread_mutex_destroy(tls *crt.TLS, mutex uintptr) int32 { + panic(todo("")) +} + +// int pthread_mutex_trylock(pthread_mutex_t *mutex); +func Xpthread_mutex_trylock(tls *crt.TLS, mutex uintptr) int32 { + panic(todo("")) +} + +// int pthread_cond_broadcast(pthread_cond_t *cond); +func Xpthread_cond_broadcast(tls *crt.TLS, cond uintptr) int32 { + panic(todo("")) +} diff --git a/internal/crt2/tcl.go b/internal/crt2/tcl.go deleted file mode 100644 index 64f2da7..0000000 --- a/internal/crt2/tcl.go +++ /dev/null @@ -1,929 +0,0 @@ -// 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("")) -// } -// -// // ============================================================================ |