From fa2b4bc58c2aa02cf9326c7f2318fab066cd85c7 Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Sat, 11 Jun 2022 18:19:54 +0200
Subject: [PATCH 01/39] - TSP Working Version MiR 2022

- fixed several bugs in .c and .tcl
- add minimal namespace support
- changed from critcl to tcc4tcl (modified tcc4tcl 0.30)
- add package helper code
---
 native/clang/TSP_cmd.c   |   6 +-
 native/clang/TSP_func.c  |  49 ++-
 native/clang/TSP_util.c  |  35 +-
 tsp-clang.tcl            | 205 ++++++++----
 tsp-compile.tcl          |  50 ++-
 tsp-expr.tcl             |  16 +-
 tsp-generate-control.tcl |   9 +-
 tsp-generate-set.tcl     |   7 +-
 tsp-generate-var.tcl     |   7 +-
 tsp-generate.tcl         |  12 +-
 tsp-logging.tcl          |   5 +-
 tsp-packagehelper.tcl    | 687 +++++++++++++++++++++++++++++++++++++++
 tsp-parse.tcl            |  13 +-
 tsp-types.tcl            |  24 +-
 tsp.tcl                  |  24 +-
 15 files changed, 1031 insertions(+), 118 deletions(-)
 create mode 100644 tsp-packagehelper.tcl

diff --git a/native/clang/TSP_cmd.c b/native/clang/TSP_cmd.c
index 8331765..511819d 100644
--- a/native/clang/TSP_cmd.c
+++ b/native/clang/TSP_cmd.c
@@ -223,6 +223,7 @@ TSP_Cmd_builtin_clock (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
     static ClientData clientData = NULL;
+    static int result;
     if (cmdProc == NULL) {
         Tcl_CmdInfo* cmdInfo;
         cmdInfo = TSP_Cmd_getCmdInfo(interp, "::clock");
@@ -233,7 +234,10 @@ TSP_Cmd_builtin_clock (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
         Tcl_IncrRefCount(cmdName);  /* from altercation  */
     }
     objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
+    // somehow we have to reset the proc, or this risks to crash
+    result= (cmdProc)(clientData, interp, objc, objv);
+    cmdProc = NULL;
+    return result;
 }
 
 int
diff --git a/native/clang/TSP_func.c b/native/clang/TSP_func.c
index fcbd2ba..b0a8b28 100644
--- a/native/clang/TSP_func.c
+++ b/native/clang/TSP_func.c
@@ -5,6 +5,7 @@
 #ifndef _MATH_H
 #include <math.h>
 #endif
+#include <stdlib.h>
 
 #ifndef _LIBC_LIMITS_H_
 #include <limits.h>
@@ -137,6 +138,7 @@ TSP_func_str_ne(Tcl_DString* s1, Tcl_DString* s2) {
     return (TSP_func_util_strcmp(s1, s2) != 0) ? TRUE : FALSE;
 }
 
+
 Tcl_WideInt
 TSP_func_int_abs(Tcl_WideInt i) {
     if (i < 0) {
@@ -318,8 +320,45 @@ _TSP_func_log10(int* rc, char** exprErrMsg, double x) {
     }
     return z;
 }
+#ifndef max
+#define max(a,b) \
+   ({ __typeof__ (a) _a = (a); \
+       __typeof__ (b) _b = (b); \
+     _a > _b ? _a : _b; })
+#endif
+#define TSP_func_max(a,b)  _TSP_func_max(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_max(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = max(x,y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " max()");
+    }
+    return z;
+}
+#ifndef min
+#define min(a,b) \
+   ({ __typeof__ (a) _a = (a); \
+       __typeof__ (b) _b = (b); \
+     _a <= _b ? _a : _b; })
+#endif
+#define TSP_func_min(a,b)  _TSP_func_min(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_min(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = min(x,y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " min()");
+    }
+    return z;
+}
 
-#define TSP_func_pow(a,b) _TSP_func_pow(rc, &exprErrMsg, (a), (b))
+#define TSP_func_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
+#define TSP_func_double_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
 double
 _TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
     double z;
@@ -332,7 +371,7 @@ _TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
     return z;
 }
 
-#define TSP_func_int_pow(a,b) _TSP_func_int_pow(rc, &exprErrMsg, (a), (b))
+#define TSP_func_int_pow(a,b) _TSP_func_double_int_pow(rc, &exprErrMsg, (a), (b))
 double
 _TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
     double z;
@@ -347,7 +386,7 @@ _TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
 
 double
 TSP_func_rand() {
-    return drand48(); 
+    return rand(); 
 }
 
 double
@@ -393,8 +432,8 @@ _TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
 
 double
 TSP_func_int_srand(Tcl_WideInt i) {
-    srand48((long) i);
-    return drand48();
+    srand((long) i);
+    return rand();
 }
 
 #define TSP_func_tan(a) _TSP_func_tan(rc, &exprErrMsg, (a))
diff --git a/native/clang/TSP_util.c b/native/clang/TSP_util.c
index 3d81eda..15c16f9 100644
--- a/native/clang/TSP_util.c
+++ b/native/clang/TSP_util.c
@@ -214,8 +214,8 @@ TSP_Util_lang_assign_var_var(Tcl_Obj* targetVarName, Tcl_Obj* sourceVarName) {
         Tcl_DecrRefCount(targetVarName);
     }
 
-    /* targetVarName = Tcl_DuplicateObj(sourceVarName);  */
-    targetVarName = sourceVarName;
+     targetVarName = Tcl_DuplicateObj(sourceVarName);  
+    //targetVarName = sourceVarName;
 
     Tcl_IncrRefCount(targetVarName);
     return targetVarName;
@@ -235,17 +235,6 @@ TSP_Util_lang_assign_array_var(Tcl_Interp* interp, Tcl_Obj* targetArrayVar, Tcl_
     }
 }
 
-
-/*********************************************************************************************/
-/* compare two Tcl_DStrings */
-int
-TSP_Util_string_compare(Tcl_DString* s1, Tcl_DString* s2) {
-    char* string2;
-    int length2;
-
-    return TSP_Util_string_compare_const(s1, Tcl_DStringValue(s2), Tcl_DStringLength(s2));
-}
-
 /*********************************************************************************************/
 /* compare a Tcl_DString to a const string. use negative length to find first null in string2 */
 int
@@ -270,6 +259,26 @@ TSP_Util_string_compare_const(Tcl_DString* s1, char* string2, int length2) {
 }
 
 
+/*********************************************************************************************/
+/* compare two Tcl_DStrings */
+int
+TSP_Util_string_compare(Tcl_DString* s1, Tcl_DString* s2) {
+    char* string2;
+    int length2;
+
+    return TSP_Util_string_compare_const(s1, Tcl_DStringValue(s2), Tcl_DStringLength(s2));
+}
+
+
+/* create Dstring from Char in tmpVar */ 
+Tcl_DString* TSP_UTIL_dstring_from_char (char* str, Tcl_DString* tmpvar) {
+    Tcl_DStringSetLength(tmpvar, 0);
+    Tcl_DStringAppend(tmpvar, str, -1);
+    return tmpvar;
+}
+
+
+
 /*********************************************************************************************/
 /* create a constant string obj                                                              */
 Tcl_Obj*
diff --git a/tsp-clang.tcl b/tsp-clang.tcl
index da489a0..b54fcab 100644
--- a/tsp-clang.tcl
+++ b/tsp-clang.tcl
@@ -2,7 +2,7 @@
 
 # language specific procs - c
 #package require tcc4tcl
-package require critcl
+package require tcc4tcl
 
 # FIXME - strings and string command impls should use Tcl_UniChar arrays, not
 #         UTF-8 strings.  
@@ -11,13 +11,13 @@ package require critcl
 # FIXME
 # for testing, set cache dir and clear cache once
 # this is ordinarily in ::tsp::lang_compile
-::critcl::cache ./.critcl
-::critcl::clean_cache
+#::critcl::cache ./.critcl
+#::critcl::clean_cache
 
 
 # force critcl to load so we can capture the original PkgInit bodhy
-catch {::critcl::cproc}
-variable ::tsp::critcl_pkginit [info body ::critcl::PkgInit]
+#catch {::critcl::cproc}
+#variable ::tsp::critcl_pkginit [info body ::critcl::PkgInit]
 
 
 # BUILTIN_TCL_COMMANDS
@@ -32,7 +32,7 @@ variable ::tsp::critcl_pkginit [info body ::critcl::PkgInit]
 # SPILL_LOAD_COMMANDS
 # commands that specify variables by name, requiring spill/load
 # each element is a list of: command subcommand-or-option start end vartype spill-load-type.  
-# if variable naem is not previously defined, it will be defined as the first type
+# if variable name is not previously defined, it will be defined as the first type
 # listed in vartype.  
 # note: this list only for commands not otherwise compiled, and also not for array
 # variable names, since they are always kept in the interp ("file stat"), 
@@ -64,7 +64,7 @@ namespace eval ::tsp {
     ]
 
     variable SPILL_LOAD_COMMANDS [list                               \
-	[list binary     scan       4  end    var      load]         \
+	    [list binary     scan       4  end    var      load]         \
         [list dict       append     2  2      var      spill/load]   \
         [list dict       incr       2  2      var      spill/load]   \
         [list dict       lappend    2  2      var      spill/load]   \
@@ -450,6 +450,15 @@ proc ::tsp::lang_get_string_var {sourceVarName} {
     return "TSP_Util_lang_get_string_var($sourceVarName)"
 }
 
+##############################################
+# get a tcl_dstring from a char value
+# NOTE - value is place into a tcl_dstring from ::tsp::get_tmpvar
+#
+proc ::tsp::lang_get_string_char {char strVar} {
+    return "TSP_UTIL_dstring_from_char(\"$char\",$strVar)"
+}
+
+
 
 ##############################################
 # preserve / incrRefCount a TclObject variable
@@ -525,7 +534,7 @@ proc ::tsp::lang_int_const {n} {
 # appends double designation for java
 proc ::tsp::lang_double_const {n} {
     if {[string is wideinteger $n] || [string is double $n]} {
-        append n d
+        #append n d
     }
     return $n
 }
@@ -897,6 +906,10 @@ proc ::tsp::lang_create_compilable {compUnitDict code} {
     # create a list of proc argument names, prepended with __
     set procArgs ""
     foreach arg [dict get $compUnit args] {
+        if {[lsearch $tsp::LOCKED_WINVARS $arg]>-1} {
+            ::tsp::addWarning compUnit " $arg is protected, rewriting to _$arg"
+            set arg _$arg
+        }
         lappend procArgs __$arg
     }
 
@@ -909,7 +922,6 @@ proc ::tsp::lang_create_compilable {compUnitDict code} {
         set nativeArgs ", $nativeArgs"
     }
 
-
     set nativeTypedArgs ""
     set intfProcArgs ""
     set intfProcInit ""
@@ -1027,7 +1039,16 @@ proc ::tsp::lang_create_compilable {compUnitDict code} {
             set returnInit ""
             set returnCleanup $missing_return
         } 
-        void -
+        void {
+            set returnVar ""
+            set returnValueCmd ""
+            set returnVarDecl ""
+            set returnVarAssignment ""
+            set intfReturnSetResult ""
+            set returnAlloc ""
+            set returnInit ""
+            set returnCleanup " goto normal_exit;"
+        }
         default {
             set returnVar ""
             set returnValueCmd ""
@@ -1043,6 +1064,10 @@ proc ::tsp::lang_create_compilable {compUnitDict code} {
     # create proc function vars and cleanup code (for vars and string)
     foreach {var} [lsort [dict keys [dict get $compUnit vars]]] {
         set type [::tsp::getVarType compUnit $var]
+        if {[lsearch $tsp::LOCKED_WINVARS $var]>-1} {
+            ::tsp::addWarning compUnit " $var is protected, rewriting to _$var"
+            set var _$var
+        }
         if {[lsearch $procArgs __$var] >= 0} {
             continue
         }
@@ -1084,7 +1109,8 @@ proc ::tsp::lang_create_compilable {compUnitDict code} {
         append argObjvArrays "Tcl_Obj** foreachObjv_0 = NULL;\n"
     }
 
-    append cleanup_defs "#define CLEANUP " \ \n
+    set cleanup_defs ""
+    append cleanup_defs "#define CLEANUP "  \ \n
     append cleanup_defs [::tsp::indent compUnit [::tsp::lang_spill_vars compUnit [dict get $compUnit finalSpill]] 1 \n]
     append cleanup_defs [::tsp::indent compUnit [::tsp::lang_safe_release _tmpVar_cmdResultObj] 1 \n]
     append cleanup_defs [::tsp::indent compUnit $procVarsCleanup 1 \n]
@@ -1092,7 +1118,7 @@ proc ::tsp::lang_create_compilable {compUnitDict code} {
 
     set arg_cleanup_defs ""
     if {[string length $declStringsCleanup]} {
-        append arg_cleanup_defs "#define CLEANUP " \ \n
+        append arg_cleanup_defs "#define CLEANUP "  \ \n
         append arg_cleanup_defs [::tsp::indent compUnit $declStringsCleanup 1 \n]
     } else {
         append arg_cleanup_defs "#define CLEANUP \n"
@@ -1123,20 +1149,25 @@ proc ::tsp::lang_create_compilable {compUnitDict code} {
     set direct_tsp_decls ""
     set direct_tsp_init  ""
     foreach cmdName [lsort [dict get $compUnit direct]] {
-
         if {$cmdName eq [dict get $compUnit name]} { 
             set proc_info  [list [dict get $compUnit returns] [dict get $compUnit argTypes] {} ]
         } else {
             set proc_info  [dict get $::tsp::COMPILED_PROCS $cmdName]
         }
         lassign $proc_info procType procArgTypes procRef
-        if {$procType ne "void"} {
+            
+        if {$procType eq "void"} {
             set procNativeType ""
         } else {
             set procNativeType "[::tsp::lang_xlate_native_type $procType] "
         }
+        if {$::tsp::PACKAGE_NAMESPACE ne ""} {
+            set nscmdName "::${::tsp::PACKAGE_NAMESPACE}::$cmdName"
+        } else {
+            set nscmdName $cmdName
+        }
         append direct_tsp_decls "static ${procNativeType}(* TSP_UserDirect_${cmdName})();\n "
-        append direct_tsp_init  "TSP_UserDirect_${cmdName} =  TSP_User_getCmd(interp, \"${cmdName}\");\n"
+        append direct_tsp_init  "TSP_UserDirect_${cmdName} =  TSP_User_getCmd(interp, \"${nscmdName}\");\n"
     }
 
     # create decls and init code for constants
@@ -1151,27 +1182,45 @@ proc ::tsp::lang_create_compilable {compUnitDict code} {
         } elseif {[::tsp::typeIsDouble $constTypes]} {
             append procConstInit "$constvar = TSP_Util_const_double((double) $const);\n"
         } else {
-            append procConstInit "$constvar = TSP_Util_const_string([::tsp::lang_quote_string $const]);\n"
+            append procConstInit "$constvar = TSP_Util_const_string([::tsp::lang_quote_string $const]);/*from create_compilable*/\n"
         }
     }
 
     # class template
+# $::tsp::HOME_DIR/native/clang/ is moved to $handle add_include_path
+# include tcl.h should be present from tcc4tcl headers
+if {$::tsp::PACKAGE_HEADER eq ""} {
+    # $::tsp::PACKAGE_HEADER gets included from tcc4tcl handle later
+    set ::tsp::PACKAGE_HEADER \
+    {
+    /* don't forget to declare includedir tsp-package/native/clang/ in the right way */
+    #include <string.h>
+    #include <tclInt.h>    
+    #include "TSP_cmd.c"
+    #include "TSP_func.c"
+    #include "TSP_util.c"
+
+    #define __i386__ 1
+    #if defined(__i386__)
+    // FPU control word for rounding to nearest mode
+    unsigned short __tcc_fpu_control = 0x137f;
+    // FPU control word for round to zero mode for int conversion
+    unsigned short __tcc_int_fpu_control = 0x137f | 0x0c00;
+    #endif
+    
+    }
+}
 
-    set cfileTemplate1 \
+set cfileTemplate1 \
 {
-
-#include <tcl.h>
-
-#include "$::tsp::HOME_DIR/native/clang/TSP_cmd.c"
-#include "$::tsp::HOME_DIR/native/clang/TSP_func.c"
-#include "$::tsp::HOME_DIR/native/clang/TSP_util.c"
-
+#undef CLEANUP
+#undef RETURN_VALUE_CLEANUP
+#undef RETURN_VALUE
+#undef ERROR_EXIT
 #define ERROR_EXIT goto error_exit
 
 $cleanup_defs
-
 $return_cleanup_def
-
 $return_var_def
 
 /* 
@@ -1189,7 +1238,9 @@ TSP_UserDirect_${name}(Tcl_Interp* interp, int* rc  $nativeTypedArgs ) {
     char* str2;     
     char* exprErrMsg = NULL;
     Tcl_Obj* _tmpVar_cmdResultObj = NULL;
-    Tcl_CallFrame* frame = NULL;
+
+    Tcl_CallFrame* frame = NULL; 
+
     $returnVarDecl
     [::tsp::indent compUnit $argObjvArrays 1 \n]
     [::tsp::indent compUnit $direct_tsp_decls 1 \n]
@@ -1223,6 +1274,10 @@ TSP_UserDirect_${name}(Tcl_Interp* interp, int* rc  $nativeTypedArgs ) {
         [::tsp::indent compUnit $procConstInit 2 \n]
     }
     
+    /* Tcl_CallFrame is dangerous since it is buried deep in the tcl_internals stubs table */
+    /* could easily break in future TCL_VERSION versions */
+    /* Made it functional against 8.6.6 with no guarantee */
+    
     frame = (Tcl_CallFrame*) ckalloc(sizeof(Tcl_CallFrame));
     Tcl_PushCallFrame(interp, frame, Tcl_GetGlobalNamespace(interp), 1);
 
@@ -1257,6 +1312,7 @@ TSP_UserDirect_${name}(Tcl_Interp* interp, int* rc  $nativeTypedArgs ) {
 #undef RETURN_VALUE
 #undef ERROR_EXIT
 
+
 $arg_cleanup_defs
 #define RETURN_VALUE_CLEANUP 
 #define RETURN_VALUE 
@@ -1325,7 +1381,6 @@ $arg_cleanup_defs
 
     # critcl needs two pieces, one for ccode and another form ccommand, so return as a list
 
-    #puts [subst $cfileTemplate1]
     #puts [subst $cfileTemplate2]
 
     return [list [subst $cfileTemplate1] [subst $cfileTemplate2]]
@@ -1349,45 +1404,69 @@ proc ::tsp::lang_compile {compUnitDict code} {
     set results ""
     set rc [catch {
         # debugging critcl
-        ::critcl::config lines 0
-        ::critcl::config keepsrc 1
-        ::critcl::cache ./.critcl
+        #::critcl::config lines 0
+        #::critcl::config keepsrc 1
+        #::critcl::cache ./.critcl
 
 # for testing, this is executed on startup, 
 # uncomment for non-dev
         #::critcl::clean_cache
 
         # redefine internal critcl print to capture error messages
-        ::proc ::critcl::print {args} {
-            append ::tsp::cc_output [lindex $args end]
-        }
+        #::proc ::critcl::print {args} {
+        #    append ::tsp::cc_output [lindex $args end]
+        #}
 
         # redefine internal critcl PkgInit to return a custom package name, becomes
         # the package init 
-        ::proc ::critcl::PkgInit {file} [list return Tsp_user_[string tolower $name]]
+        #::proc ::critcl::PkgInit {file} [list return Tsp_user_[string tolower $name]]
 
         # tcl 8.5 has wide ints, make that the min version
-        ::critcl::tcl 8.5
+        #::critcl::tcl 8.5
 
         # cause compile to fail if return is not coded in execution branch
-        if {[regexp gcc [::critcl::targetconfig]]} {
-            ::critcl::cflags -Werror=return-type -O3
-        }
+        #if {[regexp gcc [::critcl::targetconfig]]} {
+        #    ::critcl::cflags -Werror=return-type -O3
+        #}
 
         # create the code, first is the proc (ccode), second is the tcl interface (ccommand)
-        ::critcl::ccode [lindex $code 0]
-        ::critcl::ccommand ::$name {clientData interp objc objv} [lindex $code 1]
+        #::critcl::ccode [lindex $code 0]
+        #::critcl::ccommand ::$name {clientData interp objc objv} [lindex $code 1]
+        if {$::tsp::COMPILE_PACKAGE==0} {
+            set handle [tcc4tcl::new]
+            $handle add_include_path "$::tsp::HOME_DIR/native/clang/"
+            $handle ccode "$::tsp::PACKAGE_HEADER"
+        } else {
+            set handle $::tsp::TCC_HANDLE
+        }
+        $handle ccode [lindex $code 0]
+        set myns ""
+        if {$::tsp::PACKAGE_NAMESPACE ne ""} {
+            set myns "::[string trim $::tsp::PACKAGE_NAMESPACE :]"
+        }
+        $handle ccommand "${myns}::$name" {clientData interp objc objv} [lindex $code 1]
 
 	# cause critcl to compile the code and load the resulting .so lib
-        ::critcl::load
-
-        dict set compUnit compiledReference tsp.cmd.${name}Cmd
-        format "done"
+        #::critcl::load
+        if {$::tsp::COMPILE_PACKAGE==0} {
+            set compResult [$handle go]
+            puts $compResult
+            #append ::tsp::cc_output $compResult
+            ::tsp::addWarning compUnit "TCC: $compResult"
+            dict set compUnit compiledReference tsp.cmd.${name}Cmd
+        } else {
+            puts "Writing Package deffered"
+        }
+        puts "Transpiling done"
     } result ]
-    set critcl_results_dict [critcl::cresults]
+    if {$result ne ""} {
+        puts "Transpile Result: $result"
+    }
+    #set critcl_results_dict [critcl::cresults]
+    #set critcl_results_dict []
     set errors ""
 #FIXME: use exl key for new critcl version
-    catch {set errors [dict get [critcl::cresults] log]}
+    #catch {set errors [dict get [critcl::cresults] log]}
     set cc_errors ""
     foreach line [split $::tsp::cc_output \n] {
         if {[regexp -nocase error $line]} {
@@ -1398,10 +1477,10 @@ proc ::tsp::lang_compile {compUnitDict code} {
         ::tsp::addError compUnit "error compiling $name:\n$result\n$errors\n$cc_errors"
     }
 #FIXME: remove reset for new critcl version
-    catch {critcl::reset}
+    #catch {critcl::reset}
 
     # reset the PkgInit proc for other critcl usage
-    ::proc ::critcl::PkgInit {file} $::tsp::critcl_pkginit
+    #::proc ::critcl::PkgInit {file} $::tsp::critcl_pkginit
     return $rc
 }
 
@@ -1514,13 +1593,15 @@ proc ::tsp::lang_expr {compUnitDict exprAssignment} {
 }
 
 
+
 ##############################################
-# spill vars into interp, used for ::tsp::volatile,
-# compiled commands that use varName arguments, and
-# spilling final var values for upvar/global/variable.
+# spill vars from interp, used for ::tsp::volatile,
+# compiled commands that use varName arguments, 
+# and final spill for variables after upvar/global/variable
 # returns code
 # NOTE: Tcl error raised if variable is already defined as an array in the interp
 #
+
 proc ::tsp::lang_spill_vars {compUnitDict varList} {
     upvar $compUnitDict compUnit
 
@@ -1528,7 +1609,9 @@ proc ::tsp::lang_spill_vars {compUnitDict varList} {
         return ""
     }
 
-    set buf "/* ::tsp::::tsp::lang_spill_vars $varList */\n"
+    set buf "/* ::tsp::lang_spill_vars $varList */\n"
+    ::tsp::addWarning compUnit "Spilling Vars |$varList| into global namespace" 
+    
     foreach var $varList {
         set type [::tsp::getVarType compUnit $var]
         if {$type eq "undefined"} {
@@ -1553,7 +1636,10 @@ proc ::tsp::lang_spill_vars {compUnitDict varList} {
         set pre [::tsp::var_prefix $var]
 
         set varnameConst [::tsp::get_constvar [::tsp::getConstant compUnit $var]]
-
+        if {[lsearch $::tsp::NAMESPACE_VARS $var]>-1} {
+            # rewrite varname to nas
+            append buf "$varnameConst = TSP_Util_const_string([::tsp::lang_quote_string ::${::tsp::PACKAGE_NAMESPACE}::$var]);\n"
+        }
         append buf "/* interp.setVar $var */\n"
         if {$type eq "var"} {
             append buf "if ($pre$var == NULL) \{\n"
@@ -1589,7 +1675,7 @@ proc ::tsp::lang_spill_vars {compUnitDict varList} {
 # NOTE: TclException throw if variable is unset or can't convert to native type
 # returns code
 #
-proc ::tsp::lang_load_vars {compUnitDict varList setEmptyWhenNotExists} {
+proc ::tsp::lang_load_vars {compUnitDict varList setEmptyWhenNotExists {fromNamespace ""}} {
     upvar $compUnitDict compUnit
 
     set buf ""
@@ -1624,8 +1710,12 @@ proc ::tsp::lang_load_vars {compUnitDict varList setEmptyWhenNotExists} {
             set interpVar [::tsp::get_tmpvar compUnit var $var]
             set isvar 0
         }
-
-        set varnameConst [::tsp::get_constvar [::tsp::getConstant compUnit $var]]
+        
+        if {$fromNamespace ne ""} {
+            set varnameConst [::tsp::get_constvar [::tsp::getConstant compUnit "${fromNamespace}::$var"]]
+        } else {
+            set varnameConst [::tsp::get_constvar [::tsp::getConstant compUnit $var]]
+        }
 
         if {$setEmptyWhenNotExists} {
             append buf "/* ::tsp::lang_load_vars  interp.getVar $var */\n"
@@ -2029,6 +2119,7 @@ proc ::tsp::lang_return {compUnitDict argVar} {
     switch $returnType {
         string {append code "Tcl_DStringAppend(returnValue, Tcl_DStringValue($argVar), Tcl_DStringLength($argVar));\n"}
         var    {append code "returnValue = $argVar;\nTcl_IncrRefCount(returnValue);\n"}
+        void   {return  "CLEANUP;\n return;\n"}
         default {append code "returnValue = $argVar;\n"}
     }
     append code "*rc = TCL_OK;\n"
diff --git a/tsp-compile.tcl b/tsp-compile.tcl
index 404249a..9d7d7ba 100644
--- a/tsp-compile.tcl
+++ b/tsp-compile.tcl
@@ -33,7 +33,6 @@
 # compileType - normal = compile if able, none = don't compile, assert = Tcl error if not compilable, trace = enable Tcl tracing
 # compiledReference - the Java class name or C function 
 
-
 proc ::tsp::init_compunit {file name procargs body} {
    return [dict create \
         file $file \
@@ -72,11 +71,13 @@ proc ::tsp::init_compunit {file name procargs body} {
 # compile a proc 
 
 proc ::tsp::compile_proc {file name procargs body} {
-
     set compUnit [::tsp::init_compunit $file $name $procargs $body]
-
+    set ::tsp::tempspillvars {}
+    
     set procValid [::tsp::validProcName $name]
+    
     if {$procValid ne ""} {
+        puts "procValid Error in compUnit"
         ::tsp::addError compUnit $procValid
         ::tsp::logErrorsWarnings compUnit
         uplevel #0 [list ::proc $name $procargs $body]
@@ -85,19 +86,41 @@ proc ::tsp::compile_proc {file name procargs body} {
 
     set code ""
     set errInf ""
-
- 
     set rc [ catch {set compileResult [::tsp::parse_body compUnit {0 end}] } errInf] 
+    if {$rc != 0} {
+        error "tsp internal error: parse_body error: $errInf"
+    }
 
+    set returnType [dict get $compUnit returns]
+    
+    set compUnit [::tsp::init_compunit $file $name $procargs $body]
+    
+    if {$returnType eq ""} {
+        # try setting it to void
+        set pargs ""
+        foreach parg $procargs {
+            lappend pargs var
+        }
+        set compUnit [::tsp::init_compunit $file $name $procargs $body]
+        set procdef_pargs "tsp::procdef void -args [join $pargs { }]"
+        ::tsp::addWarning compUnit "Missing procdef definition, replacing with tsp::procdef void -args $pargs"
+        ::tsp::parse_procDefs compUnit "tsp::procdef void -args [join $pargs { }]"
+    }
+    
+    # reparse
+    set rc [ catch {set compileResult [::tsp::parse_body compUnit {0 end}] } errInf] 
     if {$rc != 0} {
         error "tsp internal error: parse_body error: $errInf"
     }
     
     lassign $compileResult bodyType bodyRhs code
-
+    
+    set ::tsp::lastcompunit $compUnit
+    
     set errors [::tsp::getErrors compUnit]
     set numErrors [llength $errors]
     set returnType [dict get $compUnit returns]
+    
     set compileType [dict get $compUnit compileType]
 
     if {$compileType eq "none"} {
@@ -120,7 +143,6 @@ proc ::tsp::compile_proc {file name procargs body} {
         return
     }
 
-    
     if {$numErrors > 0 } {
         if {$compileType eq "assert" || $compileType eq "trace"} {
             error "compile type: $compileType, proc $name, but resulted in errors:\n[join $errors \n]"
@@ -140,8 +162,9 @@ proc ::tsp::compile_proc {file name procargs body} {
             ::tsp::logErrorsWarnings compUnit
         } else {
             # parse_body ok, let's see if we can compile it
+            puts "Generating C-Code\n"
             set compilable [::tsp::lang_create_compilable compUnit $code]
-            ::tsp::logCompilable compUnit $compilable
+            ::tsp::logCompilable compUnit [join $compilable ""]
             set rc [::tsp::lang_compile compUnit $compilable]
             if {$rc == 0} {
                 ::tsp::lang_interp_define compUnit
@@ -157,7 +180,6 @@ proc ::tsp::compile_proc {file name procargs body} {
    
 }
 
-
 #########################################################
 # check if name is a legal identifier for compilation
 # return "" if valid, other return error condition
@@ -167,7 +189,8 @@ proc ::tsp::validProcName {name} {
         return "invalid proc name: \"$name\" is not a valid identifier"
     }
     if {[lsearch [::tsp::getCompiledProcs] $name] >= 0} {
-        return "invalid proc name: \"$name\" has been previously defined and compiled"
+        puts "warning: proc name: \"$name\" has been previously defined and compiled"
+        return ""
     }
     if {[lsearch ::tsp::BUILTIN_TCL_COMMANDS $name] >= 0} {
         return "invalid proc name: \"$name\" is builtin Tcl command"
@@ -176,7 +199,6 @@ proc ::tsp::validProcName {name} {
 }
 
 
-
 #########################################################
 # main tsp proc interface
 #
@@ -186,6 +208,12 @@ proc ::tsp::proc {name argList body} {
     if {$scriptfile eq ""} {
         set scriptfile _
     }
+    if {[string trim [namespace qualifiers $name] : ] eq $::tsp::PACKAGE_NAMESPACE} {
+        set name [namespace tail $name]
+    }
+    if {$::tsp::COMPILE_PACKAGE>0} {
+        dict set ::tsp::PACKAGE_PROCS $name [list $name $argList $body]
+    }
     ::tsp::compile_proc $scriptfile $name $argList $body
     return ""
 }
diff --git a/tsp-expr.tcl b/tsp-expr.tcl
index 7d985c0..1f7c908 100644
--- a/tsp-expr.tcl
+++ b/tsp-expr.tcl
@@ -86,6 +86,10 @@ namespace eval ::tsp {
         variable tclfunc_tan             TSP_func_tan
         variable tclfunc_tanh            TSP_func_tanh
 
+        variable tclfunc_max             TSP_func_max
+        variable tclfunc_min             TSP_func_min
+        
+        
         variable VALUE_TRUE              1
         variable VALUE_FALSE             0
 
@@ -111,12 +115,12 @@ namespace eval ::tsp {
 
     variable FUNC_0ARGS [list rand ]
     variable FUNC_1ARG  [list abs acos asin atan ceil cos cosh double exp floor int log log10 round sin sinh sqrt srand tan tanh wide ]
-    variable FUNC_2ARGS [list atan2 fmod hypot pow ] 
+    variable FUNC_2ARGS [list atan2 fmod hypot pow max min] 
 
     variable ALL_FUNCS [concat $FUNC_0ARGS $FUNC_1ARG $FUNC_2ARGS]
 
     variable FUNC_INT_RESULT     [list int round wide ]
-    variable FUNC_DOUBLE_RESULT  [list acos asin atan atan2 ceil cos cosh double exp floor fmod hypot log log10 pow rand sin sinh sqrt srand tan tanh ]
+    variable FUNC_DOUBLE_RESULT  [list acos asin atan atan2 ceil cos cosh double exp floor fmod hypot log log10 pow rand sin sinh sqrt srand tan tanh max min]
     variable FUNC_SAME_RESULT    [list abs ]
 
     # note: special handling for abs(int) vs abs(double)
@@ -131,7 +135,7 @@ namespace eval ::tsp {
         		  exp $tclfunc_exp       floor $tclfunc_floor  fmod $tclfunc_fmod  hypot $tclfunc_hypot \
         		  log $tclfunc_log       log10 $tclfunc_log10  rand $tclfunc_rand  round $tclfunc_round \
 		          sin $tclfunc_sin        sinh $tclfunc_sinh   sqrt $tclfunc_sqrt    tan $tclfunc_tan   \
-			 tanh $tclfunc_tanh  ] 
+		          tanh $tclfunc_tanh      max $tclfunc_max     min $tclfunc_min    ] 
 
 }
 
@@ -264,10 +268,12 @@ proc ::tsp::produce_binary_op {compUnitDict op expr tree} {
             # turn string comparison into function call
             set func $::tsp::OP_STRING_XLATE($op)
             if {$firstType eq "stringliteral"} {
-                set firstOperand \"${firstOperand}\"
+                set strVar [::tsp::get_tmpvar compUnit string]
+                set firstOperand [::tsp::lang_get_string_char $firstOperand $strVar]
             }
             if {$secondType eq "stringliteral"} {
-                set secondOperand \"${secondOperand}\"
+                set strVar [::tsp::get_tmpvar compUnit string]
+                set secondOperand [::tsp::lang_get_string_char $secondOperand $strVar]
             }
             return [list boolean "${func}($firstOperand, $secondOperand)"]
         } else {
diff --git a/tsp-generate-control.tcl b/tsp-generate-control.tcl
index 77a8149..b12edcf 100644
--- a/tsp-generate-control.tcl
+++ b/tsp-generate-control.tcl
@@ -353,15 +353,16 @@ proc ::tsp::gen_command_return {compUnitDict tree} {
             ::tsp::addError compUnit "wrong # args: proc return type declared as \"$returnType\", but \"return\" has arguments"
             return [list void "" ""]
         }
-        return [list void "" "\nreturn;\n"]
-    }
-
+        #return [list void "" "\n/*return deffered*/;\n"]
+        set result "\n/***** ::tsp::gen_command_return void */\n"
+        append result [::tsp::lang_return compUnit "void"] \n
+        return [list void "" $result]
+    }     
     if {[llength $tree] != 2} {
         ::tsp::addError compUnit "wrong # args: proc return type declared as \"$returnType\", \"return\" requires exactly one argument"
         return [list void "" ""]
     }
 
-
     # generate assignment to a tmp var that will be the return type
     # FIXME: probably should just return the return argument when it's the same type
     set argVar [::tsp::get_tmpvar compUnit $returnType]
diff --git a/tsp-generate-set.tcl b/tsp-generate-set.tcl
index 80e1e2b..5ac499e 100644
--- a/tsp-generate-set.tcl
+++ b/tsp-generate-set.tcl
@@ -53,11 +53,10 @@ proc ::tsp::gen_check_target_var {compUnitDict targetVarName targetType sourceTy
 #
 # NOTE that anywhere a tcl var is used, it is prefixed with "__" for native compilation, except
 #      for "array" variables, which are only accessed in the interp.  This is done anytime we
-#      call a lang specific proc (::tsp::lang_*], or generate lang indepedent code.
+#      call a lang specific proc [::tsp::lang_*], or generate lang indepedent code.
 #
 proc ::tsp::gen_command_set {compUnitDict tree} {
     upvar $compUnitDict compUnit
-    
     set errors 0
     set body [dict get $compUnit body]
   
@@ -85,7 +84,6 @@ proc ::tsp::gen_command_set {compUnitDict tree} {
         ::tsp::addError compUnit "set arg 2 invalid: \"$sourceStr\""
     }
 
-
     if {$errors} {
         return [list void "" ""]
     }
@@ -178,7 +176,6 @@ proc ::tsp::produce_set {compUnitDict tree targetComponents sourceComponents} {
     set sourceArrayIdxtext ""
     set sourceArrayIdxvar ""
     set sourceCode ""
-
     # is source an interpolated string?
     if {[llength $sourceComponents] > 1} {
         if {$targetType eq "array"} {
@@ -499,7 +496,7 @@ proc ::tsp::gen_assign_scalar_text {compUnitDict targetVarName targetType source
          double {
              switch $sourceType {
                  int {
-                     append result "$targetPre$targetVarName = (::tsp::lang_type_double) [::tsp::lang_int_const $sourceText];\n"
+                     append result "$targetPre$targetVarName = ([::tsp::lang_type_double]) [::tsp::lang_int_const $sourceText];\n"
                      return $result
                  }
                  double {
diff --git a/tsp-generate-var.tcl b/tsp-generate-var.tcl
index 1c10143..c22cbd2 100644
--- a/tsp-generate-var.tcl
+++ b/tsp-generate-var.tcl
@@ -10,7 +10,7 @@
 #
 proc ::tsp::gen_command_unset {compUnitDict tree} {
     upvar $compUnitDict compUnit
-    ::tsp::addError compUnit "unset command currently not supported"
+    ::tsp::addError compUnit "unset command currently not supported use ::unset"
     return [list void "" ""]
 }
 
@@ -186,7 +186,6 @@ proc ::tsp::gen_command_variable {compUnitDict tree} {
     append code [lindex $directResult 2]
     
     set upvared [list]
-
     # check that local variables are defined, if not define them as var
     # generate code to get vars from interp after the real variable command code
 
@@ -196,6 +195,7 @@ proc ::tsp::gen_command_variable {compUnitDict tree} {
             ::tsp::addError compUnit "variable local \"$rawLocal\" not a text var name"
             return [list void "" ""]
         }
+        
         set type [::tsp::getVarType compUnit $localVar]
         if {$type eq "undefined"} {
             if {[::tsp::isProcArg compUnit $localVar]} {
@@ -215,7 +215,7 @@ proc ::tsp::gen_command_variable {compUnitDict tree} {
 
     if {[llength $upvared] > 0} {
         append code "\n/**** load variable: $upvared */\n"
-        append code [::tsp::lang_load_vars compUnit $upvared 1]
+        append code [::tsp::lang_load_vars compUnit $upvared 1 $::tsp::PACKAGE_NAMESPACE]
     }
 
     # add upvared variables to the finalSpill
@@ -223,6 +223,7 @@ proc ::tsp::gen_command_variable {compUnitDict tree} {
     foreach var $upvared {
         if {[lsearch $existing $var] == -1} {
             dict lappend compUnit finalSpill $var
+            lappend ::tsp::NAMESPACE_VARS $var
         }
     }
 
diff --git a/tsp-generate.tcl b/tsp-generate.tcl
index 7af27d5..1f05b87 100644
--- a/tsp-generate.tcl
+++ b/tsp-generate.tcl
@@ -70,6 +70,7 @@ proc ::tsp::addArgsPerLevel {compUnitDict level argc} {
 #
 proc ::tsp::getConstant {compUnitDict value} {
     upvar $compUnitDict compUnit
+    
     if {[dict exists $compUnit constVar $value]} {
         return [dict get $compUnit constVar $value]
     } else {
@@ -173,7 +174,9 @@ proc ::tsp::gen_command {compUnitDict tree} {
         #   a call to a previously tsp compiled proc, bypass interp
         #   a call to a known tcl core command, bypass interp
         #   a call to tcl interp
-
+        if {($tsp::PACKAGE_NAMESPACE ne "")&&([string trim [namespace qualifiers $word] : ] eq $::tsp::PACKAGE_NAMESPACE)} {
+            set word [namespace tail $word]
+        }
         if {$type eq "text" && [info procs ::tsp::gen_command_$word] eq "::tsp::gen_command_$word"} {
             # command is compilable (set, if, while, string, lindex, etc.)
             return [::tsp::gen_command_$word compUnit $tree]
@@ -277,6 +280,9 @@ proc ::tsp::gen_direct_tsp_compiled {compUnitDict tree} {
     set result ""
     set cmdComponent [lindex [::tsp::parse_word compUnit [lindex $tree 0]] 0]
     set cmdName [lindex $cmdComponent 1]
+    if {($tsp::PACKAGE_NAMESPACE ne "")&&([string trim [namespace qualifiers $cmdName] : ] eq $::tsp::PACKAGE_NAMESPACE)} {
+        set cmdName [namespace tail $cmdName]
+    }
 
     if {$cmdName eq [dict get $compUnit name]} { 
         set proc_info  [list [dict get $compUnit returns] [dict get $compUnit argTypes] {} ]
@@ -311,7 +317,7 @@ proc ::tsp::gen_direct_tsp_compiled {compUnitDict tree} {
 
     return [list $procType $returnVar $result]
 }
-
+ 
 
 #########################################################
 # generate a tcl invocation
@@ -701,6 +707,7 @@ proc ::tsp::check_varname_args {compUnitDict tree} {
                         }
                         foreach node [lrange $tree $start $end] {
                             set varname [::tsp::nodeText compUnit $node]
+                            
                             if {$varname ne "" && [::tsp::getVarType compUnit $varname] eq "undefined"} {
                                 ::tsp::addWarning compUnit "\"$varname\" implicitly defined as type \"$vartype\" by command \"$cmd\""
                                 ::tsp::setVarType compUnit $varname $vartype
@@ -729,6 +736,7 @@ proc ::tsp::check_varname_args {compUnitDict tree} {
                             }
                             foreach node [lrange $tree $start $end] {
                                 set varname [::tsp::nodeText compUnit $node]
+
                                 if {$varname ne "" && [::tsp::getVarType compUnit $varname] eq "undefined"} {
                                     ::tsp::addWarning compUnit "\"$varname\" implicitly defined as type \"$vartype\" by command \"$cmd\""
                                     ::tsp::setVarType compUnit $varname $vartype
diff --git a/tsp-logging.tcl b/tsp-logging.tcl
index 83737cf..1064af9 100644
--- a/tsp-logging.tcl
+++ b/tsp-logging.tcl
@@ -160,7 +160,10 @@ proc ::tsp::logCompilable {compUnitDict compilable} {
 # optional filehandle, defaults to stderr
 # optional proc name pattern, defaults to * 
 #
-proc ::tsp::printLog {{fd stderr} {patt *}} {
+proc ::tsp::printLog {{fd stdout} {patt *}} {
+    if {$fd != "stdout"} {
+        puts [::tsp::log $patt]
+    }
     puts $fd [::tsp::log $patt]
 }
 
diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
new file mode 100644
index 0000000..824d0d4
--- /dev/null
+++ b/tsp-packagehelper.tcl
@@ -0,0 +1,687 @@
+##############################################################################
+#tsp package helper commands for tccide
+#
+# package building process
+#
+# package structure
+# PACKAGENAME_tsp_YYYY-MM-DD-hh-mm-ss.tcl (with tsp directives to create package)
+# pkgIndex.tcl
+# PACKAGENAME.puretcl.tcl (Untouched, pure TCL procs)
+# PACKAGENAME.tclorig.tcl (TCL Replacment procs)
+# PACKAGENAME.c (sourcecode, final)
+# PACKAGENAME.dll (binary file)
+# 
+##############################################################################
+
+namespace eval ::tsp {
+    # added for code package making MiR
+    variable COMPILE_PACKAGE 0
+    variable PACKAGE_NAMESPACE ""
+    variable NAMESPACE_VARS ""
+    variable PACKAGE_HEADER ""
+    variable TCC_HANDLE 
+    variable PACKAGE_PROCS ""
+
+    variable PACKAGE_NAME ""
+    variable PACKAGE_VERSION "1.0"
+    variable PACKAGE_DIR ""
+    variable TCL_VERSION "TCL_VERSION"
+    variable TCL_PROCS ""
+    # load tcls for additional sources
+    variable LOAD_TCLS ""
+    # load_dlls for dlls wich should be loaded into interp
+    variable LOAD_DLLS ""
+    # external dlls wich are dependencies and do not get loaded into interp
+    variable EXTERNAL_DLLS ""
+    variable COMPILE_DIRECTIVES ""
+    
+    # give name of save tcl source here, otherwise we use __lastsaved__.tcl
+    variable ACTSOURCE "__lastsaved__.tcl"
+}
+
+proc ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0} {tclversion TCL_VERSION}} {
+    if {$packagename eq ""} {
+        puts "Err: No package name given: use init_package packagename {packagenamespace ""} {packageversion 1.0} {tclversion TCL_VERSION}"
+        set ::tsp::COMPILE_PACKAGE 0
+        return
+    }
+    set ::tsp::COMPILE_PACKAGE 1
+    set ::tsp::PACKAGE_NAME $packagename
+    set ::tsp::PACKAGE_NAMESPACE $packagenamespace
+    set ::tsp::PACKAGE_VERSION $packageversion
+    set ::tsp::TCL_VERSION $tclversion
+    # reset system in case
+    set ::tsp::COMPILER_LOG [dict create]
+    set ::tsp::COMPILED_PROCS [dict create]
+    set ::tsp::TRACE_PROC ""
+    set ::tsp::PACKAGE_PROCS ""
+    
+    catch { unset ::tsp::TCC_HANDLE}
+    set ::tsp::TCC_HANDLE [tcc4tcl::new]
+
+    set ::tsp::PACKAGE_PROCS ""
+    set ::tsp::PACKAGE_INIT_PROC 0
+    set ::tsp::TCL_PROCS ""
+    #if {$::tsp::PACKAGE_HEADER eq ""} {
+        # $::tsp::PACKAGE_HEADER gets include from tcc4tcl handle later
+    set ::tsp::PACKAGE_HEADER \
+        {
+/* START OF PACKAGE_HEADER */
+/* don't forget to declare includedir tsp-package/native/clang/ in the right way */
+#include <string.h>
+#include <tclInt.h>
+#include "TSP_cmd.c"
+#include "TSP_func.c"
+#include "TSP_util.c"
+
+/* for tcc to work we need some constants defined */
+#define __i386__ 1
+#if defined(__i386__)
+// FPU control word for rounding to nearest mode
+unsigned short __tcc_fpu_control = 0x137f;
+// FPU control word for round to zero mode for int conversion
+unsigned short __tcc_int_fpu_control = 0x137f | 0x0c00;
+#endif
+
+/* END OF PACKAGE_HEADER */
+    }
+    #}
+    
+    $::tsp::TCC_HANDLE add_include_path "$::tsp::HOME_DIR/native/clang/"
+    $::tsp::TCC_HANDLE add_include_path $packagename
+    $::tsp::TCC_HANDLE add_library_path $packagename
+
+    $::tsp::TCC_HANDLE ccode $::tsp::PACKAGE_HEADER
+    
+    set ::tsp::LOAD_TCLS "" 
+    set ::tsp::LOAD_DLLS "" 
+    set ::tsp::EXTERNAL_DLLS "" 
+    
+}
+
+proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
+    if {$::tsp::PACKAGE_NAME eq ""} {
+         puts "Err: No package name given: use init_package packagename"
+        set ::tsp::COMPILE_PACKAGE 0
+    }
+    if {$::tsp::COMPILE_PACKAGE==0} {
+        puts "Err: No package building started: use init_package"
+        return
+    }
+
+    set tsp::PACKAGE_DIR $packagedir
+    if {![file isdir $tsp::PACKAGE_DIR]} {
+        file mkdir $tsp::PACKAGE_DIR
+    }
+    
+    ::tsp::rewrite_procnamespace
+    
+    if {$compiler eq ""} {
+        set compiler "intern"
+    }
+    if {$compiler ni "intern memory"} {
+        set ::tsp::COMPILE_DIRECTIVES [::tcc4tcl::write_packagecode $::tsp::TCC_HANDLE $::tsp::PACKAGE_NAME $tsp::PACKAGE_DIR $::tsp::PACKAGE_VERSION $::tsp::TCL_VERSION]
+    }
+    # list with four commandlines, tcc_compile, gcc_compile, cross_compile, lin64_compile
+    
+    ::tsp::write_pkgAltTcl $::tsp::PACKAGE_NAME
+    ::tsp::write_pkgIndex $::tsp::PACKAGE_NAME
+    
+    # copy source to package... if already in place, rename
+    set t [clock format [clock seconds] -format "%Y-%m-%d_%H-%M-%S"]
+    set srcname "${::tsp::PACKAGE_NAME}_tsp_${t}.tcl"
+    set srcname [file join $tsp::PACKAGE_DIR $srcname]
+    set vdiff 1
+    catch {
+        set lastsrcname [file join $tsp::PACKAGE_DIR "${::tsp::PACKAGE_NAME}_tsp_*.tcl"]
+        set lastsrcname [lindex [lsort -decreasing [glob $lastsrcname]] 0]
+        set vdiff [version:filediff $::tsp::ACTSOURCE $lastsrcname]
+    }
+    if {$vdiff >0} {
+        puts "Copy src to $srcname"
+        file copy "$::tsp::ACTSOURCE" "$srcname"
+    }
+    
+    ::tsp::compile_package $::tsp::PACKAGE_NAME $compiler
+    set ::tsp::COMPILE_PACKAGE 0
+    set ::tsp::PACKAGE_NAME ""
+}
+
+proc ::tsp::add_tclinclude {fname} {
+    # load tcls for additional sources
+    lappend ::tsp::LOAD_TCLS $fname
+}
+proc ::tsp::add_bininclude {fname} {
+    # load_dlls for dlls wich should be loaded into interp
+    lappend ::tsp::LOAD_DLLS $fname
+}
+proc ::tsp::add_dllinclude {fname} {
+    # external dlls wich are dependencies and do not get loaded into interp
+    lappend ::tsp::EXTERNAL_DLLS $fname
+}
+
+proc ::tsp::test_packageX {packagename {callcmd ""} {shell "./tclkit_866_3.upx.exe"}} {
+    # ok, now things really get difficult, if the directory structure doesn't work
+    set result "failed testloading package $packagename"
+    set callresult ""
+    puts "Testing package $packagename"
+    if {[catch {
+        puts "Creating new exec"
+        set fd [open resrc.tcl w]
+        puts "appending auto_path with [file dir $tsp::PACKAGE_DIR]"
+        puts $fd "console show"
+        puts $fd "lappend auto_path [file dir $tsp::PACKAGE_DIR]"
+        puts "Loading package... $packagename"
+        puts $fd "package require $packagename"
+        
+        if {$callcmd ne ""} {
+            puts "Calling $callcmd"
+            puts $fd $callcmd
+        }
+    } err]} {
+        puts "Error while preparing package $packagename\n$err"
+    }
+    close $fd
+    puts "Go"
+    
+    # shell actually hardcoded... todo implement some clever routine to find nearest kit
+    
+    if {[catch {
+        if {![file exists $shell]} {
+            puts "Shell not found $shell... searching"
+            # mark your shells as tclkit-8.6.6.exe to get found 866 8-6-6 all will do
+            # this will search for 8.6.6 shell
+            # or at least any 8.6 shell
+            set flist [glob tclkit*.exe]
+            set cand ""
+            foreach kit $flist {
+                set vnum [join [regexp -all -inline "\[0-9\]" $kit]]
+                set vstring2 [join [lrange $vnum 0 1] "."]
+                set vstring3 [join [lrange $vnum 0 2] "."]
+                if {$vstring2 eq "8.6"} {
+                    lappend cand $kit $vstring3
+                }
+                if {$vstring3 eq "8.6.6"} {
+                    # found an 866, use it
+                    set shell $kit
+                    puts "found $shell"
+                    break;
+                }
+            }
+            if {[llength $cand]==0} {
+                puts "Error: Shell not found"
+                return 
+            }
+            set cand [lsort -decreasing -stride 2 $cand]
+            puts "Candidates $cand"
+            set shell [lindex $cand 0]
+            puts "using $shell"
+            
+        }
+        exec $shell resrc.tcl &
+    } err]} {
+            puts "Error while preparing package $packagename\n$err"
+        }
+    return 
+}
+
+proc ::tsp::test_package {packagename {callcmd ""}} {
+    # ok, now things really get difficult, if the directory structure doesn't work
+    set result "failed testloading package $packagename"
+    set callresult ""
+    puts "Testing package $packagename"
+    if {[catch {
+        puts "Creating new interp"
+        set ip [interp create]
+        puts "appending auto_path with [file dir $tsp::PACKAGE_DIR]"
+        $ip eval lappend auto_path [file dir $tsp::PACKAGE_DIR]
+        puts "Loading package... $packagename"
+        set result [$ip eval package require $packagename]
+        if {$callcmd ne ""} {
+            puts "Calling $callcmd"
+            catch {
+                set callresult [$ip eval $callcmd]
+            } errcall
+            puts "...result:"
+            puts $callresult
+            if {$errcall ne ""} {
+                puts $errcall
+            }
+        }
+    } err]} {
+        puts "Error while testing package $packagename\n$err"
+    }
+    puts "Got Result: $result"
+    puts "deleting interp"
+    interp delete $ip
+    return $result
+}
+
+proc ::tsp::test_altpackage {packagename {callcmd ""}} {
+    # ok, now things really get difficult, if the directory structure doesn't work
+    set result "failed testloading package $packagename"
+    set callresult ""
+    puts "Testing package $packagename"
+    if {[catch {
+        puts "Creating new interp"
+        set ip [interp create]
+        puts "Loading TCL package... $packagename.tclprocs.tcl"
+        set result [$ip eval source [file join $tsp::PACKAGE_DIR "${packagename}.tclprocs.tcl"]]
+        puts "Loading TCL package... $packagename.puretcl.tcl"
+        set result [$ip eval source [file join $tsp::PACKAGE_DIR "${packagename}.puretcl.tcl"]]
+
+        #$ip eval  ${packagename}_pkgInit
+        
+        if {$callcmd ne ""} {
+            puts "Calling $callcmd"
+            catch {
+                set callresult [$ip eval $callcmd]
+            } errcall
+            puts "...result:"
+            puts $callresult
+            if {$errcall ne ""} {
+                puts $errcall
+            }
+        }
+    } err]} {
+        puts "Error while testing package $packagename\n$err"
+    }
+    puts "Got Result: $result"
+    puts "deleting interp"
+    interp delete $ip
+    return $result
+}
+    
+##############################################################################
+# internal routines
+##############################################################################
+
+proc ::tsp::rewrite_procnamespace {} {
+    if {$::tsp::PACKAGE_NAMESPACE eq ""} {
+        #return 0
+    }
+    set handle $::tsp::TCC_HANDLE
+    upvar #0 $handle state 
+    if {![array exists state]} { return}
+    if {[catch { set p $state(procs)} e]} {return}
+    set nsprocs ""
+    foreach {procname cprocname} $state(procs) {
+        if {[lsearch $::tsp::PACKAGE_PROCS [namespace tail $procname]]<0} {
+            # pure c implemented... probs ahead :-)
+            set procdef [list $procname "args" [list puts "Not implemented \"$procname\""]]
+            puts "found pure c proc $procname, replacing dummy $procdef"
+            lappend ::tsp::PACKAGE_PROCS $procname $procdef
+            set cdef [dict get $state(procdefs) $procname]
+            lassign $cdef cprocname rtype cprocargs
+            set procargs ""
+            foreach {ctype vname} $cprocargs {
+                lappend procargs $ctype
+            }
+            #lappend ::tsp::COMPILED_PROCS $procname [list $rtype $procargs $cprocname]
+        }
+    }
+    if {$::tsp::PACKAGE_NAMESPACE eq ""} {
+        return 0
+    }
+    foreach {procname cprocname} $state(procs) {
+        if {[namespace qualifier $procname] eq ""} {
+            set nsprocname "::${::tsp::PACKAGE_NAMESPACE}::$procname"
+            puts "Namespace rewriting $procname to $nsprocname"
+        } else {
+            set nsprocname $procname
+        }
+        lappend nsprocs $nsprocname $cprocname
+    }
+    set state(procs) $nsprocs
+}
+
+proc ::tsp::write_pkgIndex {packagename} {
+    # write a pkindex.tcl file to load package
+    if {$tsp::PACKAGE_DIR eq ""} {
+        set filename [file join $tsp::PACKAGE_DIR "$packagename.pkgIndex.tcl"]
+    } else {
+        set filename [file join $tsp::PACKAGE_DIR "pkgIndex.tcl"]
+    }
+    set fd [open $filename w]
+    puts $fd "# Package Index for $packagename generated by TSP//TCCIDE Version $::_version"
+    puts $fd "# Compiled Procs "
+    puts $fd ""
+    set cpr {}
+    catch {set cpr $::tsp::PACKAGE_PROCS}
+    foreach {procname procdef} $cpr {
+        lassign $procdef cproc cvars cbody
+        puts $fd "# ${::tsp::PACKAGE_NAMESPACE}::$cproc $cvars"
+    }
+    puts $fd "# TCL Procs "
+    puts $fd ""
+    set tclpr {}
+    catch {set tclpr $::tsp::TCL_PROCS}
+    foreach tcldef $tclpr {
+        lassign $tcldef cproc cvars cbody
+        puts $fd "# $cproc $cvars"
+    }
+    set handle $::tsp::TCC_HANDLE
+    set loadextlibs "proc ${packagename}_loadextdlls {dir} {\ncatch {\n"
+    append loadextlibs {set appdir [file dir [info nameofexecutable]]}
+    append loadextlibs "\n"
+    
+    set libs [$handle add_library]
+    set ::tsp::EXTERNAL_DLLS [lsort -unique $::tsp::EXTERNAL_DLLS]
+    if {$::tsp::EXTERNAL_DLLS ne ""} {
+        lappend libs {*}$::tsp::EXTERNAL_DLLS
+    }
+    foreach incpath $libs {
+        append loadextlibs "\nset incdll \[file join \$dir $incpath\[info sharedlibextension\]\]\n"
+        append loadextlibs "set appdll \[file join \$appdir $incpath\[info sharedlibextension\]\]\n"
+        append loadextlibs "if {!\[file exists \$appdll\]} {\n"
+        append loadextlibs "    puts \"Copy \$incdll --> \$appdll\"\n"
+        append loadextlibs "    file copy \$incdll \$appdll\n"
+        append loadextlibs "}\n"
+    }
+    append loadextlibs "}\n}\n"
+    if {[llength $libs] ==0} {
+        set loadextlibs ""
+    }
+    
+    set pkgloadlib  "proc ${packagename}_loadlib {dir packagename} {\n"
+    if {$loadextlibs ne ""} {
+        append pkgloadlib "     ${packagename}_loadextdlls \$dir\n"
+        append pkgloadlib "     ${packagename}_loadext \$dir\n"
+    }
+    if {$cpr ne ""} {
+        append pkgloadlib "     if {\[catch {load \[file join \$dir \$packagename\[info sharedlibextension\]\]} err\]} {\n"
+        append pkgloadlib "         source  \[file join \$dir \${packagename}.tclprocs.tcl\]\n"
+        append pkgloadlib "     }\n"
+    }
+    
+    if {$tclpr ne ""} {
+        # load puretcl proc also
+        append pkgloadlib "     source  \[file join \$dir \${packagename}.puretcl.tcl\]\n" 
+        if {$::tsp::PACKAGE_INIT_PROC>0} {
+            append pkgloadlib "     # call pkgInit procedure to initialise pkg if given\n"
+            append pkgloadlib "     return \[ catch {\${packagename}_pkgInit} e\] \n"
+        }
+    }
+    append pkgloadlib "}\n"
+    
+    set pkgloadext  "proc ${packagename}_loadext {dir} {\n"
+    foreach extdll [lsort -unique $::tsp::LOAD_DLLS] {
+        #
+        append pkgloadext "     if {\[catch {load \[file join \$dir $extdll\[info sharedlibextension\]\]} err\]} {\n"
+        append pkgloadext "         puts \"Error loading $extdll \$err\"\n"
+        append pkgloadext "     }\n"
+    }
+    foreach exttcl [lsort -unique $::tsp::LOAD_TCLS] {
+        #
+        append pkgloadext "     if {\[catch {source  \[file join \$dir ${exttcl}.tcl\]} err\]} {\n" 
+        append pkgloadext "         puts \"Error loading $exttcl \$err\"\n"
+        append pkgloadext "     }\n"
+    }
+    append pkgloadext "}\n"
+    
+    
+    set pkgrun "package ifneeded $packagename $::tsp::PACKAGE_VERSION \[list ${packagename}_loadlib \$dir {$packagename}\]\n"
+
+    puts $fd $loadextlibs
+    puts $fd $pkgloadlib
+    puts $fd $pkgloadext
+    puts $fd $pkgrun
+    close $fd
+}
+
+proc ::tsp::write_pkgAltTcl {packagename} {
+    # write an tcl file to keep all procs as alternate to compiled procs (can't load)
+    # and those procs, that we didn't compile
+    set filename [file join $tsp::PACKAGE_DIR "$packagename.tclprocs.tcl"]
+    set fd [open $filename w]
+    puts $fd "#  TSP Pure TCL procs for loadlib failure management"
+    puts $fd "#   package $packagename"
+    puts $fd "package provide $packagename $::tsp::PACKAGE_VERSION" 
+    if {$::tsp::PACKAGE_NAMESPACE ne ""} {
+        set nsvars [lsort -unique $::tsp::NAMESPACE_VARS]
+        puts $fd "namespace eval $::tsp::PACKAGE_NAMESPACE {"
+        foreach nsvar $nsvars {
+            puts $fd "variable $nsvar"
+        }
+        puts $fd "}"
+    }
+    foreach {procname procdef} $::tsp::PACKAGE_PROCS  {
+        lassign $procdef procname procargs procbody
+        if {$procname eq "${packagename}_pkgInit"} {
+            set ::tsp::PACKAGE_INIT_PROC 1
+        }
+        if {$::tsp::PACKAGE_NAMESPACE ne ""} {
+            set procname "::${::tsp::PACKAGE_NAMESPACE}::$procname"
+        }
+        # replace #tsp::altTCL makro 
+        set procbody [string map -nocase {"#tsp::altTCL " ""} $procbody]
+        puts $fd "proc $procname {$procargs} {$procbody}\n"
+    }
+    close $fd
+    
+    ::tsp::splice_src  "$::tsp::ACTSOURCE"
+    set filename [file join $tsp::PACKAGE_DIR "${packagename}.puretcl.tcl"]
+    set fd [open $filename w]
+    puts $fd "#  TSP Pure TCL procs for loadlib complemenary procs"
+    puts $fd "#   package $packagename"
+    puts $fd "#   "
+    if {$::tsp::COMPILED_PROCS eq ""} {
+        puts $fd "package provide $packagename $::tsp::PACKAGE_VERSION" 
+    }
+    if {$::tsp::PACKAGE_NAMESPACE ne ""} {
+        set nsvars [lsort -unique $::tsp::NAMESPACE_VARS]
+        puts $fd "namespace eval $::tsp::PACKAGE_NAMESPACE {"
+        foreach nsvar $nsvars {
+            puts $fd "variable $nsvar"
+        }
+        puts $fd "}"
+    }
+
+    foreach procdef $tsp::TCL_PROCS {
+        lassign $procdef procname procargs procbody
+        if {$procname eq "${packagename}_pkgInit"} {
+            set ::tsp::PACKAGE_INIT_PROC 1
+        }
+        puts $fd "proc ${procname} {$procargs} {$procbody}"
+    }
+    
+    close $fd
+}
+
+proc ::tsp::compile_package {packagename {compiler tcc}} {
+    # evtl compile c-source
+    
+    set ctype -1
+    set ctype [dict get "none -1 tcc 0 gcc 1 cross 2 lin64 3 intern 9 memory 9 export 9 debug 99" $compiler]
+    if {$ctype<0} {
+        puts "ERROR: Unknown compiler $compiler or given none..."
+        return -1
+    }
+    if {$ctype==9} {
+        puts "Compiling in Memory"
+        $::tsp::TCC_HANDLE go
+        return 1
+    }
+    if {$ctype==99} {
+        puts "Debug Source"
+        puts [$::tsp::TCC_HANDLE code]
+        return 1
+    }
+
+    if {$tsp::COMPILE_DIRECTIVES eq ""} {
+        puts "ERROR: No compiler directives found"
+        return -1
+    }
+    if {$tsp::PACKAGE_DIR eq ""} {
+        puts "No packagedir given, searching in $packagename/$packagename.c"
+        #$tsp::PACKAGE_DIR 
+        set filename [file join $tsp::PACKAGE_DIR "$packagename.c"]
+        if {![file exists $filename]} {
+            set tsp::PACKAGE_DIR $packagename
+        }
+    }
+
+    set filename [file join $tsp::PACKAGE_DIR "$packagename.c"]
+    set dllname [file join $tsp::PACKAGE_DIR "$packagename.dll"]
+    if {![file exists $filename]} {
+        puts "ERROR: $filename source not found"
+        return -1
+    }
+    
+    set wd [pwd]
+    if {$::tccenv::tccexecutabledir ne ""} {
+        cd $::tccenv::tccexecutabledir
+    }
+    set cdirect [lindex $tsp::COMPILE_DIRECTIVES $ctype]
+    #set cdirect [string map [list "$packagename.c" $filename] $cdirect]
+    #set cdirect [string map [list "$packagename.dll" $dllname] $cdirect]
+    
+    puts "Compiling external $cdirect"
+    catch {
+        eval exec $cdirect
+    } err
+    puts "Result:\n$err\n"
+    cd $wd
+    return 1
+}
+
+proc ::tsp::splice_src {filename} {
+    if {![file exists $filename]} {
+        puts "ERROR: $filename source not found"
+        return -1
+    }
+
+    set f [open "$filename"]
+    set data [read $f]
+    close $f
+    set ::tsp::TCL_PROCS ""
+    foreach {dummy procName} [regexp -all -inline -line {^[\s:]*proc (\S+)} $data] {
+        catch {
+            set procargs ""
+            set _procargs [info args $procName]
+            foreach _procarg $_procargs {
+                if {[info default $procName $_procarg def]>0} {
+                    set _procarg "$_procarg \"$def\""
+                } 
+                lappend procargs $_procarg
+            }
+            set procbody [info body $procName]
+            lappend ::tsp::TCL_PROCS  [list $procName $procargs $procbody]
+        }
+    }
+}
+
+proc version:filediff {file1 file2 {cmdEqual {version:cmdEqual}} {cmdAdd {version:cmdAdd}} {cmdDel {version:cmdDel}}} {
+        set sourcefid1 [open $file1 r]
+        set sourcefid2 [open $file2 r]
+        set ::afilediffs 0
+        
+        set ::actdiff "#------------------------------------------------\n# Src: $file1\n# Trg $file2\n"
+        set diffminor 0;# if this is set to 0, lines will be trimmed befor comparison, empty lines will be dropped
+        set found 1
+        set srcline 0
+        set trgline 0
+        while {![eof $sourcefid1] && ![eof $sourcefid2]} {
+                set lastmark [tell $sourcefid2] ;# Position in <file2> before reading the next line
+                gets $sourcefid1 line1
+                gets $sourcefid2 line2
+                if {$diffminor==0} {
+                    set line1 [string trim $line1]
+                    set line2 [string trim $line2]
+                }
+                incr srcline
+                incr trgline
+                if {$line1 eq $line2} {
+                        $cmdEqual $line1 $srcline
+                        continue
+                }
+                
+                # Lines with only whitespace are also equal
+                if {[regexp -- {^\s*$} $line1] && [regexp -- {^\s*$} $line2]} {
+                        $cmdEqual {} $srcline
+                        continue
+                }
+
+                # From here both lines are unequal
+
+                set state 0
+                while {[regexp -- {^\s*$} $line1]} {
+                        # If unequal then directly state empty lines in <file1> as deleted.
+                        $cmdDel $line1 $srcline
+                        if {![eof $sourcefid1]} {
+                                gets $sourcefid1 line1
+                                if {$line1 eq $line2} {
+                                        $cmdEqual $line1 $srcline
+                                        set state 1
+                                        break
+                                }
+                        } else {
+                                break
+                        }
+                }
+                if {$state} {
+                        continue
+                }
+                
+                # Remember position in <file2> and look forward
+                set mark2  [tell $sourcefid2]
+                set mark2a $lastmark
+                set found 0
+                while {![eof $sourcefid2]} {
+                        gets $sourcefid2 line2
+                        if {$line1 ne $line2} {
+                                set mark2a $mark2
+                                set mark2 [tell $sourcefid2]
+                        } else {
+                                # Found a matching line. Everything up to the line before are new lines
+                                seek $sourcefid2 $lastmark
+                                while {[tell $sourcefid2] <= $mark2a} {
+                                        gets $sourcefid2 line2
+                                        $cmdAdd $line2 $srcline
+                                }
+                                gets $sourcefid2 line2
+                                $cmdEqual $line2 $srcline
+                                set found 1
+                                break
+                        }
+                }
+                if {!$found} {
+                        # No matching line found in <file2>. Line must be deleted
+                        $cmdDel $line1 $srcline
+                        seek $sourcefid2 $lastmark
+                }
+        }
+        # Output the rest of <file1> as deleted
+        while {![eof $sourcefid1]} {
+                gets $sourcefid1 line1
+                $cmdDel $line1 $srcline
+        }
+
+        # Output the rest of <file2> as added
+        while {![eof $sourcefid2]} {
+                gets $sourcefid2 line2
+                $cmdAdd $line2 $srcline
+        }
+        close $sourcefid2
+        close $sourcefid1
+        if {$::afilediffs>0} {
+            lappend ::lfilediffs $file1 $file2
+            append ::tfilediffs $::actdiff
+            incr ::cfilediffs $::afilediffs
+        }
+        return $::afilediffs
+}
+proc version:cmdEqual {txt line} {
+}
+proc version:cmdAdd {txt line} {
+        append ::actdiff "$line: +$txt\n";update
+        incr ::afilediffs
+}
+proc version:cmdDel {txt line} {
+    if {[string trim $txt]!=""} {
+        append ::actdiff "$line: -$txt\n";update
+        incr ::afilediffs
+    }
+}
+
+
diff --git a/tsp-parse.tcl b/tsp-parse.tcl
index 19552d5..2c82546 100644
--- a/tsp-parse.tcl
+++ b/tsp-parse.tcl
@@ -14,7 +14,6 @@ proc ::tsp::parse_body {compUnitDict range} {
     set cmdRhsVar ""
     set cmdCode ""
    
-
     lassign $range firstIdx lastIdx
     if {$lastIdx eq "end"} {
         set lastIdx [string length $body]
@@ -51,7 +50,6 @@ proc ::tsp::parse_body {compUnitDict range} {
             # added below for loading after the command is executed
         }
         
-        
         # process comments for tsp pragmas
         lassign $commentRange commentFirst commentLast
         if {$commentLast > 0} {
@@ -62,6 +60,12 @@ proc ::tsp::parse_body {compUnitDict range} {
 
             set comment [parse getstring $body $commentRange]
             ::tsp::parse_pragma compUnit $comment
+            if {[dict exists $compUnit "immediateCode"]&&([set imcode [dict get $compUnit "immediateCode"]] ne "")} {
+                set imcode [join $imcode \n]
+                append gencode $imcode
+                dict unset compUnit "immediateCode"
+            }
+                
         }
         
         # process the command
@@ -127,7 +131,7 @@ proc ::tsp::parse_body {compUnitDict range} {
 
         # continue parsing
         set range $restRange
-	lassign $range firstIdx lastIdx
+        lassign $range firstIdx lastIdx
     }
 
     # if any errors, return null string, else return the generated code
@@ -199,6 +203,7 @@ proc ::tsp::parse_word {compUnitDict subtree {check_array 1}} {
     if {$type eq "simple"} {
         set textIdx [lindex [lindex $subtree 0] 1]
         set unquotedStr [parse getstring $body $textIdx]
+    
         if {$check_array} {
             return [::tsp::isArrayText [list [list text $wordStr $unquotedStr]] $unquotedStr]
         } else {
@@ -210,6 +215,7 @@ proc ::tsp::parse_word {compUnitDict subtree {check_array 1}} {
         incr endIdx -2
         set range [list $startIdx $endIdx]
         return [list command [::tsp::trimCommand $wordStr] $range]
+        
     } elseif {$type ne "word"} {
         return [list invalid "unknown node $type"]
     }
@@ -248,7 +254,6 @@ proc ::tsp::parse_word {compUnitDict subtree {check_array 1}} {
     }
 }
 
-
 #########################################################
 # trim [ and ] from a command string
 proc ::tsp::trimCommand {str} {
diff --git a/tsp-types.tcl b/tsp-types.tcl
index b15e080..f3e7c6f 100644
--- a/tsp-types.tcl
+++ b/tsp-types.tcl
@@ -148,6 +148,11 @@ proc ::tsp::parse_pragma {compUnitDict comments} {
                 }
             }
             
+            "tsp::inlinec*" {
+                set inlinec [string map {"tsp::inlinec " ""} $prag]
+                dict lappend compUnit "immediateCode" "/* $prag */" $inlinec
+            }
+            
         }
 
         dict incr compUnit lineNum 
@@ -161,7 +166,6 @@ proc ::tsp::parse_pragma {compUnitDict comments} {
 
 proc ::tsp::parse_procDefs {compUnitDict def} {
     upvar $compUnitDict compUnit
-
     if {[dict get $compUnit returns] ne ""} {
         ::tsp::addError compUnit "::tsp::procdef: attempt to redefine proc: $def"
         return
@@ -240,7 +244,7 @@ proc ::tsp::parse_procDefs {compUnitDict def} {
                         ::tsp::addError compUnit "::tsp::procdef: var already defined: arg \"$arg\" as type \"$previous\""
                     }
                 } else {
-		    ::tsp::setVarType compUnit $arg $type
+                    ::tsp::setVarType compUnit $arg $type
                     lappend argTypesList $type
                 }
             }
@@ -298,7 +302,6 @@ proc ::tsp::parse_varDefs {compUnitDict def} {
 
 proc ::tsp::parse_volatileDefs {compUnitDict def} {
     upvar $compUnitDict compUnit
-
     set vars [lrange $def 1 end]
     foreach var $vars {
         set isValid [::tsp::isValidIdent $var]
@@ -364,8 +367,16 @@ proc ::tsp::isProcArg {compUnitDict var} {
 # 
 proc ::tsp::isValidIdent {id} {
     #tsp::proc returns: bool args: string id 
-    
-    return [regexp {^[a-zA-Z_][a-zA-Z0-9_]*$} $id]
+    set ns [string trim [namespace qualifiers $id] ":"]
+    set vn [namespace tail $id]
+    set r [regexp {^[a-zA-Z_][a-zA-Z0-9_]*$} $vn]
+    if {$ns eq $::tsp::PACKAGE_NAMESPACE} {
+        return $r
+    }
+    if {$ns eq ""} {
+        return $r
+    }
+    return 0
 }
 
 
@@ -550,6 +561,9 @@ proc ::tsp::is_prefixedvar {name} {
 # user variables
 
 proc ::tsp::var_prefix {name} {
+    if {[lsearch $tsp::LOCKED_WINVARS $name]>-1} {
+        return ___
+    }
     if {[::tsp::is_tmpvar $name] || [::tsp::is_prefixedvar $name]} {
         return ""
     } else {
diff --git a/tsp.tcl b/tsp.tcl
index 8863582..5a20b28 100644
--- a/tsp.tcl
+++ b/tsp.tcl
@@ -7,7 +7,25 @@ namespace eval ::tsp {
     variable VAR_TYPES [list boolean int double string array var]
     variable NATIVE_TYPES [list boolean int double string]
     variable RETURN_TYPES [list void boolean int double string var]
-  
+    
+    # added for code package making MiR see also tsp-packagehelper.tcl
+    variable COMPILE_PACKAGE 0
+    variable PACKAGE_NAMESPACE ""
+    variable NAMESPACE_VARS ""
+    variable PACKAGE_HEADER ""
+    variable TCC_HANDLE 
+    variable PACKAGE_PROCS ""
+    
+    # Locked global vars from stdlib in WIN32 and MINGW ... this is rather annoying MiR
+    # TSP rewrites variable/argmunetnames with __
+    # this interfers with some #defines from stdlib.h at least
+    # if compiled code crashes for no obvious reason
+    # maybe we found another reserved extern defined global variable
+    # That's what I hate C for :-) lots of included headers and getting a pointer conversion warning at best if you redefine those (tcc won't even warn on this)
+    # so did a quick search for every __ prefixed symbol and locked it up... lets see how far we get
+    
+    variable LOCKED_WINVARS {argc argv targv wargv mb_cur_max mb_cur_max_dll argc_dll argv_dll imp__environ_dll imp__sys_nerr imp__sys_nerr_dll imp__sys_errlist CRT_INLINE CRT_STRINGIZE CRT_UNALIGNED CRT_WIDE DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_0 DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1 DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1_ARGLIST DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2 DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2_ARGLIST DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_3 DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_4 DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_1 DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_2 DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_3 DEFINE_CPP_OVERLOAD_SECURE_FUNC_2_0 DEFINE_CPP_OVERLOAD_SECURE_FUNC_SPLITPATH EMPTY_DECLSPEC ERRCODE_DEFINED_MS GNUC_VA_LIST MINGW_ATTRIB_CONST MINGW_ATTRIB_DEPRECATED MINGW_ATTRIB_MALLOC MINGW_ATTRIB_NONNULL MINGW_ATTRIB_NORETURN MINGW_ATTRIB_PURE MINGW_FPCLASS_DEFINED MINGW_H MINGW_IMPORT MINGW_NOTHROW MSVCRT__ RETURN_POLICY_DST RETURN_POLICY_SAME RETURN_POLICY_VOID TRY__ WIN32__ _mb_cur_max_func argc argv attribute__ builtin_alloca builtin_isgreater builtin_isgreaterequal builtin_isless builtin_islessequal builtin_islessgreater builtin_isunordered crt_typefix declspec dst fastcall finddata64_t fpclassifyf i386__ inline__ int16 int32 int64 int8 int8_t_defined intptr_t_defined iob_func mb_cur_max mbcur_max mingw_access mingw_snprintf mingw_vsnprintf signbitf stat64 static_assert_t stdcall swprintf_l try__ uintptr_t_defined unaligned va_copy va_end va_start vswprintf_l wargv x86_64}
+
     # compiler log for all procs, keys are "filename,procname" errors|warnings, entries are list of: errors/warnings
     # most recent compilation has key of _
     variable COMPILER_LOG [dict create]
@@ -33,7 +51,7 @@ namespace eval ::tsp {
 
     # other ::tsp namespace variables are set in language specific files, 
     # e.g., tsp-java.tcl, tsp-clang.tcl
-} 
+}                                                                           
 
 set ::tsp::HOME_DIR [file normalize [file dirname [info script]]]
 
@@ -51,6 +69,8 @@ source [file join [file dirname [info script]] tsp-generate-var.tcl]
 source [file join [file dirname [info script]] tsp-generate-list.tcl]
 source [file join [file dirname [info script]] tsp-generate-string.tcl]
 
+source [file join [file dirname [info script]] tsp-packagehelper.tcl]
+
 # source the language specific module
 if {$::tcl_platform(platform) eq "java"} {
     source [file join [file dirname [info script]] tsp-java.tcl]

From 235e87d127b2e952f10a23dfce5fbe4ec947ef9a Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Thu, 23 Jun 2022 19:17:58 +0200
Subject: [PATCH 02/39] - fix some minor bugs in type conversions - add
 isNative interface to compUnit to drop Tcl_PushCallframe/Tcl_PopCallframe
 where possible

---
 tsp-clang.tcl         | 38 ++++++++++++++++++++++++++++----------
 tsp-generate-set.tcl  |  1 +
 tsp-packagehelper.tcl |  7 ++++++-
 tsp-types.tcl         | 25 ++++++++++++++++++++++++-
 4 files changed, 59 insertions(+), 12 deletions(-)

diff --git a/tsp-clang.tcl b/tsp-clang.tcl
index b54fcab..604cf12 100644
--- a/tsp-clang.tcl
+++ b/tsp-clang.tcl
@@ -353,7 +353,7 @@ proc ::tsp::lang_convert_double_var {targetVarName sourceVarName errMsg} {
 proc ::tsp::lang_convert_string_boolean {targetVarName sourceVarName {errMsg ""}} {
     append result "/* ::tsp::lang_convert_string_boolean */\n"
     append result "Tcl_DStringSetLength($targetVarName,0);\n"
-    append result "Tcl_DStringAppend($targetVarName, ($sourceVarName ? : \"1\" : \"0\"), -1);\n"
+    append result "Tcl_DStringAppend($targetVarName, ($sourceVarName ? \"1\" : \"0\"), -1);\n"
     return $result
 }
 
@@ -415,7 +415,7 @@ proc ::tsp::lang_convert_var_var {targetVarName sourceVarName {errMsg ""}} {
 # NOTE - return value must be used immediately
 #
 proc ::tsp::lang_get_string_boolean {sourceVarName} {
-    return "$sourceVarName ? : \"1\" : \"0\""
+    return "$sourceVarName ? \"1\" : \"0\""
 }
 
 ##############################################
@@ -1109,6 +1109,7 @@ proc ::tsp::lang_create_compilable {compUnitDict code} {
         append argObjvArrays "Tcl_Obj** foreachObjv_0 = NULL;\n"
     }
 
+    
     set cleanup_defs ""
     append cleanup_defs "#define CLEANUP "  \ \n
     append cleanup_defs [::tsp::indent compUnit [::tsp::lang_spill_vars compUnit [dict get $compUnit finalSpill]] 1 \n]
@@ -1127,8 +1128,27 @@ proc ::tsp::lang_create_compilable {compUnitDict code} {
     regsub "^\[ \n\]*" $cleanup_defs {} cleanup_defs
     regsub -all {\n *$} $cleanup_defs "\n" cleanup_defs
     regsub -all {\n} $cleanup_defs "\\\n" cleanup_defs
-    append cleanup_defs "    Tcl_PopCallFrame(interp); \\\n" 
-    append cleanup_defs "    ckfree((char*) frame) \n"
+    
+# patch for native compiled routines, that don't need pushcallframe/popcallframe
+set popcf ""
+set pushcf "/* Native proc, no external variables used, dropping PushCallframe/PopCallframe */"
+
+if {[dict get $compUnit isNative]==0} { 
+    set pushcf {
+    /* Tcl_CallFrame is dangerous since it is buried deep in the tcl_internals stubs table */
+    /* could easily break in future TCL_VERSION versions */
+    /* Made it functional against 8.6.6 with no guarantee */
+    frame = (Tcl_CallFrame*) ckalloc(sizeof(Tcl_CallFrame));
+    Tcl_PushCallFrame(interp, frame, Tcl_GetGlobalNamespace(interp), 1);
+    }
+    set popcf "    Tcl_PopCallFrame(interp); \\\n    ckfree((char*) frame) \n"
+    puts "$name is NOT a native proc"
+} else {
+    puts "$name is a native proc"
+}
+
+
+    append cleanup_defs $popcf
 
     regsub "^\[ \n\]*" $arg_cleanup_defs {} arg_cleanup_defs
     regsub -all {\n *$} $arg_cleanup_defs "\n" arg_cleanup_defs
@@ -1211,6 +1231,7 @@ if {$::tsp::PACKAGE_HEADER eq ""} {
     }
 }
 
+
 set cfileTemplate1 \
 {
 #undef CLEANUP
@@ -1274,12 +1295,7 @@ TSP_UserDirect_${name}(Tcl_Interp* interp, int* rc  $nativeTypedArgs ) {
         [::tsp::indent compUnit $procConstInit 2 \n]
     }
     
-    /* Tcl_CallFrame is dangerous since it is buried deep in the tcl_internals stubs table */
-    /* could easily break in future TCL_VERSION versions */
-    /* Made it functional against 8.6.6 with no guarantee */
-    
-    frame = (Tcl_CallFrame*) ckalloc(sizeof(Tcl_CallFrame));
-    Tcl_PushCallFrame(interp, frame, Tcl_GetGlobalNamespace(interp), 1);
+    $pushcf
 
     *rc = TCL_OK;     
 
@@ -1611,6 +1627,8 @@ proc ::tsp::lang_spill_vars {compUnitDict varList} {
 
     set buf "/* ::tsp::lang_spill_vars $varList */\n"
     ::tsp::addWarning compUnit "Spilling Vars |$varList| into global namespace" 
+    ::tsp::addWarning compUnit "::tsp::spill: Function not native"
+    dict set compUnit isNative 0
     
     foreach var $varList {
         set type [::tsp::getVarType compUnit $var]
diff --git a/tsp-generate-set.tcl b/tsp-generate-set.tcl
index 5ac499e..8dea751 100644
--- a/tsp-generate-set.tcl
+++ b/tsp-generate-set.tcl
@@ -547,6 +547,7 @@ proc ::tsp::gen_assign_scalar_scalar {compUnitDict targetVarName targetType sour
 
     upvar $compUnitDict compUnit
 
+    
     # set the target as dirty
     # puts "gen_assign_scalar_scalar- ::tsp::setDirty compUnit $targetVarName"
     ::tsp::setDirty compUnit $targetVarName 
diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index 824d0d4..b907149 100644
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -120,7 +120,12 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
         set compiler "intern"
     }
     if {$compiler ni "intern memory"} {
-        set ::tsp::COMPILE_DIRECTIVES [::tcc4tcl::write_packagecode $::tsp::TCC_HANDLE $::tsp::PACKAGE_NAME $tsp::PACKAGE_DIR $::tsp::PACKAGE_VERSION $::tsp::TCL_VERSION]
+        if {[info commands "::tcc4tcl::write_packagecode"] ne "::tcc4tcl::write_packagecode"} {
+            set ::tsp::COMPILE_DIRECTIVES ""
+            puts "failed crafting compiledirectives... use package require tcc4tcc-helper"
+        } else {
+            set ::tsp::COMPILE_DIRECTIVES [::tcc4tcl::write_packagecode $::tsp::TCC_HANDLE $::tsp::PACKAGE_NAME $tsp::PACKAGE_DIR $::tsp::PACKAGE_VERSION $::tsp::TCL_VERSION]
+        }
     }
     # list with four commandlines, tcc_compile, gcc_compile, cross_compile, lin64_compile
     
diff --git a/tsp-types.tcl b/tsp-types.tcl
index f3e7c6f..0feb50a 100644
--- a/tsp-types.tcl
+++ b/tsp-types.tcl
@@ -173,7 +173,11 @@ proc ::tsp::parse_procDefs {compUnitDict def} {
     
     set validReturnTypes $::tsp::RETURN_TYPES
     set validArgTypes $::tsp::VAR_TYPES
-
+    
+    # patch for native proc withou pushcallframe/popcallframe
+    dict set compUnit isNative 1
+    set unsupportedTypes "array"
+    
     set len [llength $def]
     if {$len < 2} {
         ::tsp::addError compUnit "::tsp::procdef: invalid proc definition, missing return type"
@@ -188,6 +192,13 @@ proc ::tsp::parse_procDefs {compUnitDict def} {
         ::tsp::addError compUnit "::tsp::procdef: invalid return type: $type"
         return
     }
+    set unsupported [lsearch $unsupportedTypes $type]
+    if {$unsupported>-1} {
+        ::tsp::addWarning compUnit "::tsp::procdef: not a native type $type"
+        dict set compUnit isNative 0
+        return
+    }
+    
     dict set compUnit returns $type
     set argTypesList [list]
     set procArgs [dict get $compUnit args]
@@ -233,6 +244,12 @@ proc ::tsp::parse_procDefs {compUnitDict def} {
                 ::tsp::addError compUnit "::tsp::procdef: proc arg is not valid identifier: $arg"
             }
             set type [lindex $defArgs $i]
+            set unsupported [lsearch $unsupportedTypes $type]
+            if {$unsupported>-1} {
+                ::tsp::addWarning compUnit "::tsp::procdef: not a native type $type"
+                dict set compUnit isNative 0
+                return
+            }
             set found [lsearch $validArgTypes $type]
             if {$found < 0} {
                 ::tsp::addError compUnit "::tsp::procdef: invalid proc definition: arg $arg type \"$type\" is invalid"
@@ -275,6 +292,12 @@ proc ::tsp::parse_varDefs {compUnitDict def} {
         ::tsp::addError compUnit "::tsp::def: invalid var type: \"$type\""
         return
     }
+    set unsupported [lsearch "array" $type]
+    if {$unsupported>-1} {
+        ::tsp::addWarning compUnit "::tsp::procdef: not a native type $type"
+        dict set compUnit isNative 0
+        return
+    }
 
     set var_list [lrange $def 1 end]
     foreach var $var_list {

From 4188631631058b5336c75d0e330425ab5016b1cf Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Fri, 1 Jul 2022 17:09:38 +0200
Subject: [PATCH 03/39] - add #define TSP_REMOVABLE static inline to enable tcc
 dead code removal

---
 native/clang/TSP_cmd.c  | 188 +++++++++++++++++++++-------------------
 native/clang/TSP_func.c |  74 ++++++++--------
 native/clang/TSP_util.c |  40 ++++-----
 3 files changed, 154 insertions(+), 148 deletions(-)

diff --git a/native/clang/TSP_cmd.c b/native/clang/TSP_cmd.c
index 511819d..e587ea3 100644
--- a/native/clang/TSP_cmd.c
+++ b/native/clang/TSP_cmd.c
@@ -35,10 +35,16 @@ TSP_Cmd_getCmdInfo(Tcl_Interp* interp, char* cmd) {
      return &cmdInfo;
 }
 
+/* define TSP_REMOVABLE as static inline     to enable tcc dead code elimination */
+#ifdef __TINYC__
+#define TSP_REMOVABLE static inline 
+#else
+#define TSP_REMOVABLE static
+#endif
 
 /* builtins command - a function that calls the builtin and fills in command obj name */
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_after (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -56,7 +62,7 @@ TSP_Cmd_builtin_after (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_append (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -74,7 +80,7 @@ TSP_Cmd_builtin_append (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_apply (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -92,7 +98,7 @@ TSP_Cmd_builtin_apply (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_array (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -110,7 +116,7 @@ TSP_Cmd_builtin_array (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_binary (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -128,7 +134,7 @@ TSP_Cmd_builtin_binary (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_break (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -146,7 +152,7 @@ TSP_Cmd_builtin_break (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_case (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -164,7 +170,7 @@ TSP_Cmd_builtin_case (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_catch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -182,7 +188,7 @@ TSP_Cmd_builtin_catch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_cd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -200,7 +206,7 @@ TSP_Cmd_builtin_cd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_O
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_chan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -218,7 +224,7 @@ TSP_Cmd_builtin_chan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_clock (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -240,7 +246,7 @@ TSP_Cmd_builtin_clock (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return result;
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_close (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -258,7 +264,7 @@ TSP_Cmd_builtin_close (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_concat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -276,7 +282,7 @@ TSP_Cmd_builtin_concat (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_continue (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -294,7 +300,7 @@ TSP_Cmd_builtin_continue (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_dict (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -312,7 +318,7 @@ TSP_Cmd_builtin_dict (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_encoding (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -330,7 +336,7 @@ TSP_Cmd_builtin_encoding (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_eof (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -348,7 +354,7 @@ TSP_Cmd_builtin_eof (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_error (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -366,7 +372,7 @@ TSP_Cmd_builtin_error (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_eval (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -384,7 +390,7 @@ TSP_Cmd_builtin_eval (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_exec (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -402,7 +408,7 @@ TSP_Cmd_builtin_exec (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_exit (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -420,7 +426,7 @@ TSP_Cmd_builtin_exit (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_expr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -438,7 +444,7 @@ TSP_Cmd_builtin_expr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_fblocked (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -456,7 +462,7 @@ TSP_Cmd_builtin_fblocked (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_fconfigure (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -474,7 +480,7 @@ TSP_Cmd_builtin_fconfigure (ClientData dummy, Tcl_Interp* interp, int objc, stru
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_fcopy (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -492,7 +498,7 @@ TSP_Cmd_builtin_fcopy (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_file (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -510,7 +516,7 @@ TSP_Cmd_builtin_file (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_fileevent (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -528,7 +534,7 @@ TSP_Cmd_builtin_fileevent (ClientData dummy, Tcl_Interp* interp, int objc, struc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_flush (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -546,7 +552,7 @@ TSP_Cmd_builtin_flush (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_for (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -564,7 +570,7 @@ TSP_Cmd_builtin_for (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_foreach (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -582,7 +588,7 @@ TSP_Cmd_builtin_foreach (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_format (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -600,7 +606,7 @@ TSP_Cmd_builtin_format (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_gets (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -618,7 +624,7 @@ TSP_Cmd_builtin_gets (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_glob (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -636,7 +642,7 @@ TSP_Cmd_builtin_glob (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_global (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -654,7 +660,7 @@ TSP_Cmd_builtin_global (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_if (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -672,7 +678,7 @@ TSP_Cmd_builtin_if (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_O
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_incr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -690,7 +696,7 @@ TSP_Cmd_builtin_incr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_info (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -708,7 +714,7 @@ TSP_Cmd_builtin_info (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_interp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -726,7 +732,7 @@ TSP_Cmd_builtin_interp (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_join (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -744,7 +750,7 @@ TSP_Cmd_builtin_join (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_lappend (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -762,7 +768,7 @@ TSP_Cmd_builtin_lappend (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_lassign (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -780,7 +786,7 @@ TSP_Cmd_builtin_lassign (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_lindex (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -798,7 +804,7 @@ TSP_Cmd_builtin_lindex (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_linsert (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -816,7 +822,7 @@ TSP_Cmd_builtin_linsert (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_list (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -834,7 +840,7 @@ TSP_Cmd_builtin_list (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_llength (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -852,7 +858,7 @@ TSP_Cmd_builtin_llength (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_lmap (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -870,7 +876,7 @@ TSP_Cmd_builtin_lmap (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_load (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -888,7 +894,7 @@ TSP_Cmd_builtin_load (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_lrange (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -906,7 +912,7 @@ TSP_Cmd_builtin_lrange (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_lrepeat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -924,7 +930,7 @@ TSP_Cmd_builtin_lrepeat (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_lreplace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -942,7 +948,7 @@ TSP_Cmd_builtin_lreplace (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_lreverse (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -960,7 +966,7 @@ TSP_Cmd_builtin_lreverse (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_lsearch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -978,7 +984,7 @@ TSP_Cmd_builtin_lsearch (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_lset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -996,7 +1002,7 @@ TSP_Cmd_builtin_lset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_lsort (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1014,7 +1020,7 @@ TSP_Cmd_builtin_lsort (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_namespace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1032,7 +1038,7 @@ TSP_Cmd_builtin_namespace (ClientData dummy, Tcl_Interp* interp, int objc, struc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_open (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1050,7 +1056,7 @@ TSP_Cmd_builtin_open (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_package (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1068,7 +1074,7 @@ TSP_Cmd_builtin_package (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_pid (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1086,7 +1092,7 @@ TSP_Cmd_builtin_pid (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_proc (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1104,7 +1110,7 @@ TSP_Cmd_builtin_proc (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_puts (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1122,7 +1128,7 @@ TSP_Cmd_builtin_puts (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_pwd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1140,7 +1146,7 @@ TSP_Cmd_builtin_pwd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_read (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1158,7 +1164,7 @@ TSP_Cmd_builtin_read (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_regexp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1176,7 +1182,7 @@ TSP_Cmd_builtin_regexp (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_regsub (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1194,7 +1200,7 @@ TSP_Cmd_builtin_regsub (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_rename (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1212,7 +1218,7 @@ TSP_Cmd_builtin_rename (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_return (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1230,7 +1236,7 @@ TSP_Cmd_builtin_return (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_scan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1248,7 +1254,7 @@ TSP_Cmd_builtin_scan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_seek (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1266,7 +1272,7 @@ TSP_Cmd_builtin_seek (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_set (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1284,7 +1290,7 @@ TSP_Cmd_builtin_set (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_socket (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1302,7 +1308,7 @@ TSP_Cmd_builtin_socket (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_source (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1320,7 +1326,7 @@ TSP_Cmd_builtin_source (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_split (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1338,7 +1344,7 @@ TSP_Cmd_builtin_split (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_string (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1356,7 +1362,7 @@ TSP_Cmd_builtin_string (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_subst (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1374,7 +1380,7 @@ TSP_Cmd_builtin_subst (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_switch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1392,7 +1398,7 @@ TSP_Cmd_builtin_switch (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_tailcall (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1410,7 +1416,7 @@ TSP_Cmd_builtin_tailcall (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_tell (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1428,7 +1434,7 @@ TSP_Cmd_builtin_tell (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_time (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1446,7 +1452,7 @@ TSP_Cmd_builtin_time (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_trace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1464,7 +1470,7 @@ TSP_Cmd_builtin_trace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_try (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1482,7 +1488,7 @@ TSP_Cmd_builtin_try (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_unload (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1500,7 +1506,7 @@ TSP_Cmd_builtin_unload (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_unset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1518,7 +1524,7 @@ TSP_Cmd_builtin_unset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_update (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1536,7 +1542,7 @@ TSP_Cmd_builtin_update (ClientData dummy, Tcl_Interp* interp, int objc, struct T
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_uplevel (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1554,7 +1560,7 @@ TSP_Cmd_builtin_uplevel (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_upvar (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1572,7 +1578,7 @@ TSP_Cmd_builtin_upvar (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_variable (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1590,7 +1596,7 @@ TSP_Cmd_builtin_variable (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_vwait (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1608,7 +1614,7 @@ TSP_Cmd_builtin_vwait (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_while (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1626,7 +1632,7 @@ TSP_Cmd_builtin_while (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_yield (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1644,7 +1650,7 @@ TSP_Cmd_builtin_yield (ClientData dummy, Tcl_Interp* interp, int objc, struct Tc
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_yieldto (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
@@ -1662,7 +1668,7 @@ TSP_Cmd_builtin_yieldto (ClientData dummy, Tcl_Interp* interp, int objc, struct
     return (cmdProc)(clientData, interp, objc, objv);
 }
 
-int
+TSP_REMOVABLE int
 TSP_Cmd_builtin_zlib (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
     static Tcl_ObjCmdProc* cmdProc = NULL;
     static Tcl_Obj* cmdName = NULL;
diff --git a/native/clang/TSP_func.c b/native/clang/TSP_func.c
index b0a8b28..fc9366c 100644
--- a/native/clang/TSP_func.c
+++ b/native/clang/TSP_func.c
@@ -25,7 +25,7 @@
 /* functions that can raise errors have macros to add rc and exprErrMsg parameters */
 
 #define TSP_func_int_div(a,b) _TSP_func_int_div(rc, &exprErrMsg, (a), (b))
-Tcl_WideInt
+TSP_REMOVABLE Tcl_WideInt
 _TSP_func_int_div(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
     Tcl_WideInt quotient;
 
@@ -50,7 +50,7 @@ _TSP_func_int_div(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt
 
 
 #define TSP_func_int_mod(a,b) _TSP_func_int_mod(rc, &exprErrMsg, (a), (b))
-Tcl_WideInt
+TSP_REMOVABLE Tcl_WideInt
 _TSP_func_int_mod(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
     Tcl_WideInt remainder = 0;
     int neg_divisor = 0;
@@ -82,7 +82,7 @@ _TSP_func_int_mod(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt
 
 
 #define TSP_func_double_div(a,b) _TSP_func_double_div(rc, &exprErrMsg, (a), (b))
-double
+TSP_REMOVABLE double
 _TSP_func_double_div(int* rc, char** exprErrMsg, double x, double y) {
     CHECK_NAN(x);
     CHECK_NAN(y);
@@ -93,7 +93,7 @@ _TSP_func_double_div(int* rc, char** exprErrMsg, double x, double y) {
     }
 }
 
-int
+TSP_REMOVABLE int
 TSP_func_util_strcmp(Tcl_DString* s1, Tcl_DString* s2) {
     int match;
     int length1 = Tcl_DStringLength(s1);
@@ -108,38 +108,38 @@ TSP_func_util_strcmp(Tcl_DString* s1, Tcl_DString* s2) {
     }
 }
 
-int
+TSP_REMOVABLE int
 TSP_func_str_lt(Tcl_DString* s1, Tcl_DString* s2) {
     return (TSP_func_util_strcmp(s1, s2) < 0) ? TRUE : FALSE;
 }
 
-int
+TSP_REMOVABLE int
 TSP_func_str_gt(Tcl_DString* s1, Tcl_DString* s2) {
     return (TSP_func_util_strcmp(s1, s2) > 0) ? TRUE : FALSE;
 }
 
-int
+TSP_REMOVABLE int
 TSP_func_str_le(Tcl_DString* s1, Tcl_DString* s2) {
     return (TSP_func_util_strcmp(s1, s2) <= 0) ? TRUE : FALSE;
 }
 
-int
+TSP_REMOVABLE int
 TSP_func_str_ge(Tcl_DString* s1, Tcl_DString* s2) {
     return (TSP_func_util_strcmp(s1, s2) >= 0) ? TRUE : FALSE;
 }
 
-int
+TSP_REMOVABLE int
 TSP_func_str_eq(Tcl_DString* s1, Tcl_DString* s2) {
     return (TSP_func_util_strcmp(s1, s2) == 0) ? TRUE : FALSE;
 }
 
-int
+TSP_REMOVABLE int
 TSP_func_str_ne(Tcl_DString* s1, Tcl_DString* s2) {
     return (TSP_func_util_strcmp(s1, s2) != 0) ? TRUE : FALSE;
 }
 
 
-Tcl_WideInt
+TSP_REMOVABLE Tcl_WideInt
 TSP_func_int_abs(Tcl_WideInt i) {
     if (i < 0) {
         if (i == LLONG_MIN) {
@@ -152,7 +152,7 @@ TSP_func_int_abs(Tcl_WideInt i) {
     }
 }
 
-double
+TSP_REMOVABLE double
 TSP_func_double_abs(double x) {
     CHECK_NAN(x);
     if (x < 0) {
@@ -163,7 +163,7 @@ TSP_func_double_abs(double x) {
 }
 
 #define TSP_func_acos(a)  _TSP_func_acos(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_acos(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
@@ -175,7 +175,7 @@ _TSP_func_acos(int* rc, char** exprErrMsg, double x) {
 }
 
 #define TSP_func_asin(a) _TSP_func_asin(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_asin(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
@@ -187,7 +187,7 @@ _TSP_func_asin(int* rc, char** exprErrMsg, double x) {
 }
 
 #define TSP_func_atan(a) _TSP_func_atan(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_atan(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
@@ -199,7 +199,7 @@ _TSP_func_atan(int* rc, char** exprErrMsg, double x) {
 }
 
 #define TSP_func_atan2(a,b) _TSP_func_atan2(rc, &exprErrMsg, (a), (b))
-double
+TSP_REMOVABLE double
 _TSP_func_atan2(int* rc, char** exprErrMsg, double x, double y) {
     double z;
     CHECK_NAN(x);
@@ -212,7 +212,7 @@ _TSP_func_atan2(int* rc, char** exprErrMsg, double x, double y) {
 }
 
 #define TSP_func_ceil(a)  _TSP_func_ceil(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_ceil(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
@@ -224,7 +224,7 @@ _TSP_func_ceil(int* rc, char** exprErrMsg, double x) {
 }
 
 #define TSP_func_cos(a) _TSP_func_cos(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_cos(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
@@ -236,7 +236,7 @@ _TSP_func_cos(int* rc, char** exprErrMsg, double x) {
 }
 
 #define TSP_func_cosh(a) _TSP_func_cosh(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_cosh(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
@@ -248,7 +248,7 @@ _TSP_func_cosh(int* rc, char** exprErrMsg, double x) {
 }
 
 #define TSP_func_exp(a) _TSP_func_exp(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_exp(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
@@ -260,7 +260,7 @@ _TSP_func_exp(int* rc, char** exprErrMsg, double x) {
 }
 
 #define TSP_func_floor(a) _TSP_func_floor(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_floor(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
@@ -272,7 +272,7 @@ _TSP_func_floor(int* rc, char** exprErrMsg, double x) {
 }
 
 #define TSP_func_fmod(a) _TSP_func_fmod(rc, &exprErrMsg, (a), (b))
-double
+TSP_REMOVABLE double
 _TSP_func_fmod(int* rc, char** exprErrMsg, double x, double y) {
     double z;
     CHECK_NAN(x);
@@ -285,7 +285,7 @@ _TSP_func_fmod(int* rc, char** exprErrMsg, double x, double y) {
 }
 
 #define TSP_func_hypot(a,b) _TSP_func_hypot(rc, &exprErrMsg, (a), (b))
-double
+TSP_REMOVABLE double
 _TSP_func_hypot(int* rc, char** exprErrMsg, double x, double y) {
     double z;
     CHECK_NAN(x);
@@ -298,7 +298,7 @@ _TSP_func_hypot(int* rc, char** exprErrMsg, double x, double y) {
 }
 
 #define TSP_func_log(a) _TSP_func_log(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_log(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
@@ -310,7 +310,7 @@ _TSP_func_log(int* rc, char** exprErrMsg, double x) {
 }
 
 #define TSP_func_log10(a) _TSP_func_log10(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_log10(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
@@ -327,7 +327,7 @@ _TSP_func_log10(int* rc, char** exprErrMsg, double x) {
      _a > _b ? _a : _b; })
 #endif
 #define TSP_func_max(a,b)  _TSP_func_max(rc, &exprErrMsg, (a), (b))
-double
+TSP_REMOVABLE double
 _TSP_func_max(int* rc, char** exprErrMsg, double x, double y) {
     double z;
     CHECK_NAN(x);
@@ -345,7 +345,7 @@ _TSP_func_max(int* rc, char** exprErrMsg, double x, double y) {
      _a <= _b ? _a : _b; })
 #endif
 #define TSP_func_min(a,b)  _TSP_func_min(rc, &exprErrMsg, (a), (b))
-double
+TSP_REMOVABLE double
 _TSP_func_min(int* rc, char** exprErrMsg, double x, double y) {
     double z;
     CHECK_NAN(x);
@@ -359,7 +359,7 @@ _TSP_func_min(int* rc, char** exprErrMsg, double x, double y) {
 
 #define TSP_func_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
 #define TSP_func_double_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
-double
+TSP_REMOVABLE double
 _TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
     double z;
     CHECK_NAN(x);
@@ -372,7 +372,7 @@ _TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
 }
 
 #define TSP_func_int_pow(a,b) _TSP_func_double_int_pow(rc, &exprErrMsg, (a), (b))
-double
+TSP_REMOVABLE double
 _TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
     double z;
     CHECK_NAN(x);
@@ -384,18 +384,18 @@ _TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
 }
 
 
-double
+TSP_REMOVABLE double
 TSP_func_rand() {
     return rand(); 
 }
 
-double
+TSP_REMOVABLE double
 TSP_func_round(double x) {
     return round(x);
 }
 
 #define TSP_func_sin(a) _TSP_func_sin(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_sin(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
@@ -407,7 +407,7 @@ _TSP_func_sin(int* rc, char** exprErrMsg, double x) {
 }
 
 #define TSP_func_sinh(a) _TSP_func_sinh(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_sinh(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
@@ -419,7 +419,7 @@ _TSP_func_sinh(int* rc, char** exprErrMsg, double x) {
 }
 
 #define TSP_func_sqrt(a) _TSP_func_sqrt(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
@@ -430,14 +430,14 @@ _TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
     return z;
 }
 
-double
+TSP_REMOVABLE double
 TSP_func_int_srand(Tcl_WideInt i) {
     srand((long) i);
     return rand();
 }
 
 #define TSP_func_tan(a) _TSP_func_tan(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_tan(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
@@ -449,7 +449,7 @@ _TSP_func_tan(int* rc, char** exprErrMsg, double x) {
 }
 
 #define TSP_func_tanh(a) _TSP_func_tanh(rc, &exprErrMsg, (a))
-double
+TSP_REMOVABLE double
 _TSP_func_tanh(int* rc, char** exprErrMsg, double x) {
     double z;
     CHECK_NAN(x);
diff --git a/native/clang/TSP_util.c b/native/clang/TSP_util.c
index 15c16f9..a17879f 100644
--- a/native/clang/TSP_util.c
+++ b/native/clang/TSP_util.c
@@ -5,7 +5,7 @@
 
 /*********************************************************************************************/
 /* convert to an int from a string */
-int
+TSP_REMOVABLE int
 TSP_Util_lang_convert_int_string(Tcl_Interp* interp, Tcl_DString* sourceVarName, Tcl_WideInt* targetVarName) {
     int rc;
     Tcl_Obj* obj = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
@@ -18,7 +18,7 @@ TSP_Util_lang_convert_int_string(Tcl_Interp* interp, Tcl_DString* sourceVarName,
 
 /*********************************************************************************************/
 /* convert to an int from a string const */
-int
+TSP_REMOVABLE int
 TSP_Util_lang_convert_int_string_const(Tcl_Interp* interp, char* sourceVarName, Tcl_WideInt* targetVarName) {
     int rc;
     Tcl_Obj* obj = Tcl_NewStringObj(sourceVarName, -1);
@@ -31,7 +31,7 @@ TSP_Util_lang_convert_int_string_const(Tcl_Interp* interp, char* sourceVarName,
 
 /*********************************************************************************************/
 /* convert to a string from an int */
-Tcl_DString*
+TSP_REMOVABLE Tcl_DString*
 TSP_Util_lang_convert_string_int(Tcl_Interp* interp, Tcl_DString* targetVarName, Tcl_WideInt sourceVarName) {
     char str[500];
     char *format = "%" TCL_LL_MODIFIER "d";
@@ -50,7 +50,7 @@ TSP_Util_lang_convert_string_int(Tcl_Interp* interp, Tcl_DString* targetVarName,
 
 /*********************************************************************************************/
 /* convert to a string from a double */
-Tcl_DString*
+TSP_REMOVABLE Tcl_DString*
 TSP_Util_lang_convert_string_double(Tcl_Interp* interp, Tcl_DString* targetVarName, double sourceVarName) {
     char str[500];
     if (targetVarName != NULL) {
@@ -67,7 +67,7 @@ TSP_Util_lang_convert_string_double(Tcl_Interp* interp, Tcl_DString* targetVarNa
 
 /*********************************************************************************************/
 /* convert to a string from a var */
-Tcl_DString*
+TSP_REMOVABLE Tcl_DString*
 TSP_Util_lang_convert_string_var(Tcl_DString* targetVarName, Tcl_Obj* sourceVarName) {
     char* str;
     int len;
@@ -86,7 +86,7 @@ TSP_Util_lang_convert_string_var(Tcl_DString* targetVarName, Tcl_Obj* sourceVarN
 /*********************************************************************************************/
 /* get a string from an int */
 /* string must be used immediately */
-Tcl_DString*
+TSP_REMOVABLE Tcl_DString*
 TSP_Util_lang_get_string_int(Tcl_WideInt sourceVarName) {
     static int doInit = 1;
     static Tcl_DString ds;
@@ -106,7 +106,7 @@ TSP_Util_lang_get_string_int(Tcl_WideInt sourceVarName) {
 /*********************************************************************************************/
 /* get a string from an double */
 /* string must be used immediately */
-Tcl_DString*
+TSP_REMOVABLE Tcl_DString*
 TSP_Util_lang_get_string_double(double sourceVarName) {
     static int doInit = 1;
     static Tcl_DString ds;
@@ -123,7 +123,7 @@ TSP_Util_lang_get_string_double(double sourceVarName) {
 /*********************************************************************************************/
 /* get a string from a var */
 /* string must be used immediately */
-Tcl_DString*
+TSP_REMOVABLE Tcl_DString*
 TSP_Util_lang_get_string_var(Tcl_Obj* sourceVarName) {
     static int doInit = 1;
     static Tcl_DString ds;
@@ -143,7 +143,7 @@ TSP_Util_lang_get_string_var(Tcl_Obj* sourceVarName) {
 
 /*********************************************************************************************/
 /* assign a var from a boolean */
-Tcl_Obj*
+TSP_REMOVABLE Tcl_Obj*
 TSP_Util_lang_assign_var_boolean(Tcl_Obj* targetVarName, int sourceVarName) {
     if (targetVarName != NULL) {
         Tcl_DecrRefCount(targetVarName);
@@ -156,7 +156,7 @@ TSP_Util_lang_assign_var_boolean(Tcl_Obj* targetVarName, int sourceVarName) {
 
 /*********************************************************************************************/
 /* assign a var from an int */
-Tcl_Obj*
+TSP_REMOVABLE Tcl_Obj*
 TSP_Util_lang_assign_var_int(Tcl_Obj* targetVarName, Tcl_WideInt sourceVarName) {
     if (targetVarName != NULL) {
         Tcl_DecrRefCount(targetVarName);
@@ -169,7 +169,7 @@ TSP_Util_lang_assign_var_int(Tcl_Obj* targetVarName, Tcl_WideInt sourceVarName)
 
 /*********************************************************************************************/
 /* assign a var from an double */
-Tcl_Obj*
+TSP_REMOVABLE Tcl_Obj*
 TSP_Util_lang_assign_var_double(Tcl_Obj* targetVarName, double sourceVarName) {
     if (targetVarName != NULL) {
         Tcl_DecrRefCount(targetVarName);
@@ -182,7 +182,7 @@ TSP_Util_lang_assign_var_double(Tcl_Obj* targetVarName, double sourceVarName) {
 
 /*********************************************************************************************/
 /* assign a var from an string */
-Tcl_Obj*
+TSP_REMOVABLE Tcl_Obj*
 TSP_Util_lang_assign_var_string(Tcl_Obj* targetVarName, Tcl_DString* sourceVarName) {
     if (targetVarName != NULL) {
         Tcl_DecrRefCount(targetVarName);
@@ -195,7 +195,7 @@ TSP_Util_lang_assign_var_string(Tcl_Obj* targetVarName, Tcl_DString* sourceVarNa
 
 /*********************************************************************************************/
 /* assign a var from an string const */
-Tcl_Obj*
+TSP_REMOVABLE Tcl_Obj*
 TSP_Util_lang_assign_var_string_const(Tcl_Obj* targetVarName, char* sourceVarName) {
     if (targetVarName != NULL) {
         Tcl_DecrRefCount(targetVarName);
@@ -208,7 +208,7 @@ TSP_Util_lang_assign_var_string_const(Tcl_Obj* targetVarName, char* sourceVarNam
 
 /*********************************************************************************************/
 /* assign a var from a var */
-Tcl_Obj*
+TSP_REMOVABLE Tcl_Obj*
 TSP_Util_lang_assign_var_var(Tcl_Obj* targetVarName, Tcl_Obj* sourceVarName) {
     if (targetVarName != NULL) {
         Tcl_DecrRefCount(targetVarName);
@@ -224,7 +224,7 @@ TSP_Util_lang_assign_var_var(Tcl_Obj* targetVarName, Tcl_Obj* sourceVarName) {
 
 /*********************************************************************************************/
 /* assign an array & element from a var */
-int
+TSP_REMOVABLE int
 TSP_Util_lang_assign_array_var(Tcl_Interp* interp, Tcl_Obj* targetArrayVar, Tcl_Obj* targetIdxVar, Tcl_Obj* var) {
     Tcl_Obj* obj;
     obj = Tcl_ObjSetVar2(interp, targetArrayVar, targetIdxVar, var, TCL_LEAVE_ERR_MSG);
@@ -237,7 +237,7 @@ TSP_Util_lang_assign_array_var(Tcl_Interp* interp, Tcl_Obj* targetArrayVar, Tcl_
 
 /*********************************************************************************************/
 /* compare a Tcl_DString to a const string. use negative length to find first null in string2 */
-int
+TSP_REMOVABLE int
 TSP_Util_string_compare_const(Tcl_DString* s1, char* string2, int length2) {
     char* string1;
     int length1;
@@ -261,7 +261,7 @@ TSP_Util_string_compare_const(Tcl_DString* s1, char* string2, int length2) {
 
 /*********************************************************************************************/
 /* compare two Tcl_DStrings */
-int
+TSP_REMOVABLE int
 TSP_Util_string_compare(Tcl_DString* s1, Tcl_DString* s2) {
     char* string2;
     int length2;
@@ -281,7 +281,7 @@ Tcl_DString* TSP_UTIL_dstring_from_char (char* str, Tcl_DString* tmpvar) {
 
 /*********************************************************************************************/
 /* create a constant string obj                                                              */
-Tcl_Obj*
+TSP_REMOVABLE Tcl_Obj*
 TSP_Util_const_string(char* str) {
     Tcl_Obj* constObj;
     constObj = Tcl_NewStringObj(str, -1);
@@ -291,7 +291,7 @@ TSP_Util_const_string(char* str) {
 
 /*********************************************************************************************/
 /* create a constant wide int obj                                                            */
-Tcl_Obj*
+TSP_REMOVABLE Tcl_Obj*
 TSP_Util_const_int(Tcl_WideInt i) {
     Tcl_Obj* constObj;
     constObj = Tcl_NewWideIntObj(i);
@@ -301,7 +301,7 @@ TSP_Util_const_int(Tcl_WideInt i) {
 
 /*********************************************************************************************/
 /* create a constant double obj                                                              */
-Tcl_Obj*
+TSP_REMOVABLE Tcl_Obj*
 TSP_Util_const_double(double d) {
     Tcl_Obj* constObj;
     constObj = Tcl_NewDoubleObj(d);

From 29430f12fd2e91df07666ddaa6dbf4e24cd2694d Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Wed, 6 Jul 2022 16:46:22 +0200
Subject: [PATCH 04/39] -added break on error to tsp::log // tsp::printLog

tsp:printLog will now return with -code error if transpilation contains errors
---
 tsp-logging.tcl | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/tsp-logging.tcl b/tsp-logging.tcl
index 1064af9..ae0f9ba 100644
--- a/tsp-logging.tcl
+++ b/tsp-logging.tcl
@@ -160,11 +160,11 @@ proc ::tsp::logCompilable {compUnitDict compilable} {
 # optional filehandle, defaults to stderr
 # optional proc name pattern, defaults to * 
 #
-proc ::tsp::printLog {{fd stdout} {patt *}} {
+proc ::tsp::printLog {{fd stdout} {patt *} {breakeval 1}} {
     if {$fd != "stdout"} {
         puts [::tsp::log $patt]
     }
-    puts $fd [::tsp::log $patt]
+    puts $fd [::tsp::log $patt $breakeval]
 }
 
 
@@ -173,8 +173,9 @@ proc ::tsp::printLog {{fd stdout} {patt *}} {
 # optional filehandle, defaults to stderr
 # optional proc name pattern, defaults to * 
 #
-proc ::tsp::log {{patt *}} {
+proc ::tsp::log {{patt *} {breakeval 0}} {
     set result ""
+    set numerrors 0
     set keys [lsort [dict keys $::tsp::COMPILER_LOG]]
     foreach key $keys {
         if {[string match $patt $key]} {
@@ -187,9 +188,17 @@ proc ::tsp::log {{patt *}} {
             foreach warn [dict get $::tsp::COMPILER_LOG $key warnings] {
                 append result "    $warn" \n
             }
+            incr numerrors [llength [dict get $::tsp::COMPILER_LOG $key errors]]
         }
     }
-    return $result
+    if {$numerrors==0} {
+        return $result
+    }
+    if {$breakeval>0} {
+        return -code error "$result\n $numerrors errors in transpiling unit, execution halted\n "
+    } else {
+        return "$result\n $numerrors errors in transpiling unit\n "
+    }
 }
 
 

From 44020c052cb75916373125722d1af21c4940c622 Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Wed, 6 Jul 2022 17:09:39 +0200
Subject: [PATCH 05/39] Added error handling for compilation

tsp::compile_package will throw an error, if compilation fails
---
 tsp-packagehelper.tcl | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index b907149..ffe7979 100644
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -545,8 +545,12 @@ proc ::tsp::compile_package {packagename {compiler tcc}} {
     catch {
         eval exec $cdirect
     } err
-    puts "Result:\n$err\n"
     cd $wd
+    puts "Result:\n$err\n"
+    if {[string first " error: " $err]>-1} {
+        puts "Compiling seems to have errors, execution halted"
+        return -code error
+    }
     return 1
 }
 

From 7ba5cd787d11375da268ffc613b330bd876b5837 Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Wed, 6 Jul 2022 17:34:07 +0200
Subject: [PATCH 06/39] added errorhandling to tsp::compile_package

uses errorCode from exec to find compiler errors for external compilers
---
 tsp-packagehelper.tcl | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index ffe7979..6998315 100644
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -547,8 +547,9 @@ proc ::tsp::compile_package {packagename {compiler tcc}} {
     } err
     cd $wd
     puts "Result:\n$err\n"
-    if {[string first " error: " $err]>-1} {
+    if {[llength $::errorCode]>1} {
         puts "Compiling seems to have errors, execution halted"
+        puts "errorCode $::errorCode"
         return -code error
     }
     return 1

From d11b26ced845d6eacd13c63be8682537eb8dc602 Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Wed, 6 Jul 2022 18:03:22 +0200
Subject: [PATCH 07/39] Update README.md

---
 lib/README.md | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/lib/README.md b/lib/README.md
index 2522fde..e6215ad 100644
--- a/lib/README.md
+++ b/lib/README.md
@@ -6,13 +6,16 @@ The following packages are required for use with C/Tcl.
 JTcl does not require any external packages, as the required
 packages 'hyde' and 'parser' are included in the JTcl distribution.
 
-critcl-3.1.15
-    https://github.com/andreas-kupries/critcl/releases
+critcl-3.1.15 is no longer needed for tsp4tcc uses tcc4tcl
+
+crtitcl can be found here, just in case    https://github.com/andreas-kupries/critcl/releases
 
 
 tclparser-1.4.1
     Tclparser provides the 'parser' package.  This package is extracted from
     the TclPro open source project.
 
+Precompiled binaries for win32 and linux64 are store in the subdir parser together with a pkgIndex.tcl
+
     Original source:  http://tclpro.cvs.sourceforge.net/viewvc/tclpro/tclparser/ 
     License:  BSD, see tclparser-1.4.1/license.terms

From fec23f4965c8e8e9b88d3bb18f34625b6f03132d Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Wed, 6 Jul 2022 18:07:03 +0200
Subject: [PATCH 08/39] add parser binaries

---
 parser/readme.md | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 parser/readme.md

diff --git a/parser/readme.md b/parser/readme.md
new file mode 100644
index 0000000..a04ac2f
--- /dev/null
+++ b/parser/readme.md
@@ -0,0 +1 @@
+This are precompiled binaries of the tclParser for win32 and linux64

From bba04831fe8102ff5a7c38c930385d76dd336a57 Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Wed, 6 Jul 2022 18:07:37 +0200
Subject: [PATCH 09/39] added binaries for tclParser

---
 parser/pkgIndex.tcl  |   1 +
 parser/tclParser.c   | 971 +++++++++++++++++++++++++++++++++++++++++++
 parser/tclparser.dll | Bin 0 -> 17920 bytes
 parser/tclparser.so  | Bin 0 -> 14496 bytes
 4 files changed, 972 insertions(+)
 create mode 100644 parser/pkgIndex.tcl
 create mode 100644 parser/tclParser.c
 create mode 100644 parser/tclparser.dll
 create mode 100644 parser/tclparser.so

diff --git a/parser/pkgIndex.tcl b/parser/pkgIndex.tcl
new file mode 100644
index 0000000..360dd31
--- /dev/null
+++ b/parser/pkgIndex.tcl
@@ -0,0 +1 @@
+package ifneeded parser 0.1 [list load [file join $dir tclparser[info sharedlibextension]]]
diff --git a/parser/tclParser.c b/parser/tclParser.c
new file mode 100644
index 0000000..a39b903
--- /dev/null
+++ b/parser/tclParser.c
@@ -0,0 +1,971 @@
+/* 
+ * tclParser.c --
+ *
+ *	This is a Tcl language parser as a Tcl dynamically loadable
+ *	extension.
+ *
+ * Copyright (c) 1996 by Sun Microsystems, Inc.
+ * Copyright (c) 2000 Ajuba Solutions
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: tclParser.c,v 1.7 2007/07/08 19:53:05 kennykb Exp $
+ */
+
+/*
+ * tclInt.h is used for TclFindElement
+ */
+ 
+ /* i686-w64-mingw32-gcc -shared -s -m32 -D_WIN32 -Iincludetcl -Iincludetcl/win -Iinclude/xlib ./tclParser.c -Llib -ltclstub86 -Llib  -otclparser.dll */
+
+#define USE_TCL_STUBS
+#include <tclInt.h>
+
+/*
+ * TCL_TOKEN_EXPAND_WORD is new in 8.5, but it's safe to define it
+ * when building in earlier releases, and a version of tclparser
+ * built that way continues to work in 8.5.
+ */
+
+#ifndef TCL_TOKEN_EXPAND_WORD
+#define TCL_TOKEN_EXPAND_WORD 256
+#endif
+
+/*
+ * The max number of characters needed to sprintf
+ * an integer, a space and a double.
+ */
+
+#define MAX_RANGE_SIZE 100
+
+/*
+ * name and version of this package
+ */
+
+static char packageName[] = "parser";
+static char packageVersion[] = "1.001";
+
+/*
+ * Declarations for functions defined in this file.
+ */
+
+#ifdef BUILD_tclparser
+#undef TCL_STORAGE_CLASS
+#define TCL_STORAGE_CLASS DLLEXPORT
+#endif
+
+EXTERN int Tclparser_Init _ANSI_ARGS_((Tcl_Interp *interp));
+
+static int	ParseMakeTokenList _ANSI_ARGS_((char *script,
+		    Tcl_Parse *parsePtr, int index, Tcl_Obj **resultPtr));
+static Tcl_Obj *ParseMakeRange _ANSI_ARGS_((char *script, CONST char *start,
+		    int end));
+static int	ParseObjCmd _ANSI_ARGS_((ClientData clientData,
+		    Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]));
+static void	ParseSetErrorCode _ANSI_ARGS_((Tcl_Interp *interp,
+		    char *script, Tcl_Parse *parsePtr));
+static int	ParseCommand _ANSI_ARGS_((Tcl_Interp *interp, char *script, 
+		    int index, int length));
+static int	ParseExpr _ANSI_ARGS_((Tcl_Interp *interp, char *script, 
+		    int index, int length));
+static int	ParseList _ANSI_ARGS_((Tcl_Interp *interp, char *script, 
+		    int index, int length));
+static int	ParseVarName _ANSI_ARGS_((Tcl_Interp *interp, char *script, 
+		    int index, int length));
+static int	ParseGetString _ANSI_ARGS_((Tcl_Interp *interp, char *script, 
+		    int index, int length));
+static int	ParseCharIndex _ANSI_ARGS_((Tcl_Interp *interp, char *script,
+		    int index, int length));
+static int	ParseCharLength _ANSI_ARGS_((Tcl_Interp *interp, char *script,
+		    int index, int length));
+static int	ParseCountNewline _ANSI_ARGS_((Tcl_Interp *interp,
+		    char *script, int scriptLength, Tcl_Obj *rangePtr1,
+		    Tcl_Obj *rangePtr2));
+static int	ParseGetIndexAndLength _ANSI_ARGS_((Tcl_Interp *interp, 
+		    Tcl_Obj *rangePtr, int scriptLen, int *index,
+		    int *length));
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tclparser_Init --
+ *
+ *	This procedure initializes the parse command.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tclparser_Init(interp)
+    Tcl_Interp *interp;
+{
+    if (Tcl_InitStubs(interp, "8.1", 0) == NULL) {
+	return TCL_ERROR;
+    }
+    Tcl_CreateObjCommand(interp, "parse", ParseObjCmd, NULL, NULL);
+    return Tcl_PkgProvide(interp, packageName, packageVersion);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ParseObjCmd --
+ *
+ *	This function implements the Tcl "parse" command.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+ParseObjCmd(dummy, interp, objc, objv)
+    ClientData dummy;		/* Not used. */
+    Tcl_Interp *interp;		/* Current interpreter. */
+    int objc;			/* Number of arguments. */
+    Tcl_Obj *CONST objv[];	/* Argument objects. */
+{
+    int option, index, length, scriptLength;
+    char *script;
+
+    static const char *options[] = {
+	 "command", "expr", "varname", "list",
+	 "getrange", "getstring", "charindex", "charlength",
+	 "countnewline", NULL
+    };
+    enum options {
+	PARSE_COMMAND, PARSE_EXPR, PARSE_VARNAME, PARSE_LIST, 
+	PARSE_GET_RANGE, PARSE_GET_STR, PARSE_CHAR_INDEX, PARSE_CHAR_LEN, 
+	PARSE_COUNT_NWLNE
+    };
+
+    if (objc < 3) {
+	Tcl_WrongNumArgs(interp, 1, objv, "option arg ?arg ...?");
+	return TCL_ERROR;
+    }
+    if (Tcl_GetIndexFromObj(interp, objv[1], options, "option", 0, &option)
+	    != TCL_OK) {
+    	return TCL_ERROR;
+    }
+
+    /*
+     * Check the number arguments passed to the command and
+     * extract information (script, index, length) depending
+     * upon the option selected.
+     */
+
+    script = Tcl_GetStringFromObj(objv[2], &scriptLength);
+    switch ((enum options) option) {
+	case PARSE_GET_RANGE:
+	    if (objc == 3) {
+		index = 0;
+		length = scriptLength;
+	    } else if (objc == 5) {
+		if (Tcl_GetIntFromObj(interp, objv[3], &index) != TCL_OK) {
+		    return TCL_ERROR;
+		}
+		if (Tcl_GetIntFromObj(interp, objv[4], &length) != TCL_OK) {
+		    return TCL_ERROR;
+		}
+		if (index < 0) {
+		    index = 0;
+		} else if (index >= scriptLength) {
+		    index = scriptLength - 1;
+		}
+		if (length < 0) {
+		    length = 0;
+		} else if (length > (scriptLength - index)) {
+		    length = scriptLength - index;
+		}
+	    } else {
+		Tcl_WrongNumArgs(interp, 2, objv, "string ?index length?");
+		return TCL_ERROR;
+	    }
+	    Tcl_SetObjResult(interp, ParseMakeRange(script, script + index,
+		    length));
+	    return TCL_OK;
+
+	case PARSE_COMMAND:
+	case PARSE_EXPR:
+	case PARSE_VARNAME:
+	case PARSE_LIST:
+	case PARSE_GET_STR: 
+	case PARSE_CHAR_INDEX:
+	case PARSE_CHAR_LEN: {
+	    if (objc != 4) {
+		Tcl_WrongNumArgs(interp, 2, objv, "string range");
+		return TCL_ERROR;
+	    }
+	    if (ParseGetIndexAndLength(interp, objv[3], scriptLength,  
+		&index, &length) != TCL_OK) {
+		return TCL_ERROR;	
+	    }	    
+	    switch ((enum options) option) {
+		case PARSE_COMMAND:
+		    return ParseCommand(interp, script, index, length);
+		case PARSE_EXPR:
+		    return ParseExpr(interp, script, index, length);
+		case PARSE_VARNAME:
+		    return ParseVarName(interp, script, index, length);
+		case PARSE_LIST:
+		    return ParseList(interp, script, index, length);
+		case PARSE_GET_STR:
+		    return ParseGetString(interp, script, index, length);
+		case PARSE_CHAR_INDEX:
+		    return ParseCharIndex(interp, script, index, length);
+		case PARSE_CHAR_LEN:
+		    return ParseCharLength(interp, script, index, length);
+		case PARSE_GET_RANGE:
+		case PARSE_COUNT_NWLNE:
+		    /* No Op - This will suppress compiler warnings */
+		    break;
+	    }
+	    break;
+	}
+	case PARSE_COUNT_NWLNE: {
+	    Tcl_Obj *range2;
+	    if (objc == 5) {
+		range2 = objv[4];
+	    } else if (objc == 4) {
+		range2 = NULL;
+	    } else {
+		Tcl_WrongNumArgs(interp, 2, objv, "string range ?range?");
+		return TCL_ERROR;
+	    }
+	    return ParseCountNewline(interp, script, scriptLength,
+		    objv[3], range2);
+	}
+    }
+    return TCL_ERROR;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ParseCommand --
+ *
+ *	This function parses a script into Tcl commands by calling the
+ *	Tcl_ParseCommand function.  This routine returns a list of the
+ *	following form: <commentRange> <commandRange> <restRange> <parseTree>
+ *	The first range refers to any leading comments before the command.
+ *	The second range refers to the command itself.  The third range
+ *	contains the remainder of the original range that appears after
+ *	the command range.  The parseTree is a list representation
+ *	of the parse tree where each node is a list in the form:
+ *	<type> <range> <subTree>.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int 
+ParseCommand(interp, script, index, length)
+    Tcl_Interp *interp;		/* Current interpreter. */
+    char *script;		/* Script to parse. */
+    int index;			/* Index to the starting point of the 
+				 * script. */
+    int length;			/* Byte length of script be parsed. */
+{
+    Tcl_Obj *resultPtr, *listPtr, *tokenPtr;
+    Tcl_Parse parse;
+    int  i;
+    CONST char *start, *end;
+
+    start = script + index;
+
+    if (Tcl_ParseCommand(interp, start, length, 0, &parse)
+	    != TCL_OK) {
+	ParseSetErrorCode(interp, script, &parse);
+	return TCL_ERROR;
+    }
+
+    resultPtr = Tcl_GetObjResult(interp);
+    i = 0;
+    if (parse.commentStart) {
+	Tcl_ListObjAppendElement(interp, resultPtr,
+		ParseMakeRange(script, parse.commentStart, parse.commentSize));
+    } else {
+	Tcl_ListObjAppendElement(interp, resultPtr,
+		ParseMakeRange(script, script, 0));
+    }
+    Tcl_ListObjAppendElement(interp, resultPtr,
+	    ParseMakeRange(script, parse.commandStart, parse.commandSize));
+    end = parse.commandStart + parse.commandSize;
+    Tcl_ListObjAppendElement(interp, resultPtr, 
+	    ParseMakeRange(script, end, length - (int) (end - start)));
+    listPtr = Tcl_NewListObj(0, NULL);
+    while (i < parse.numTokens) {
+	i = ParseMakeTokenList(script, &parse, i, &tokenPtr);
+	Tcl_ListObjAppendElement(NULL, listPtr, tokenPtr);
+    }
+    Tcl_ListObjAppendElement(interp, resultPtr, listPtr);
+    Tcl_SetObjResult(interp, resultPtr);
+    Tcl_FreeParse(&parse);
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ParseExpr --
+ *
+ *	This function parses a Tcl expression into a tree representation.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+ParseExpr(interp, script, index, length)
+    Tcl_Interp *interp;		/* Current interpreter. */
+    char *script;		/* Script to parse. */
+    int index;			/* Index to the starting point of the 
+				 * script. */
+    int length;			/* Byte length of script be parsed. */
+{
+    Tcl_Obj *resultPtr;
+    Tcl_Parse parse;
+
+    resultPtr = Tcl_GetObjResult(interp);
+    
+    if (Tcl_ParseExpr(interp, script + index, length, &parse)
+	    != TCL_OK) {
+	ParseSetErrorCode(interp, script, &parse);
+	return TCL_ERROR;
+    }
+
+    /*
+     * There is only one top level token, so just return it.
+     */
+
+    ParseMakeTokenList(script, &parse, 0, &resultPtr);
+    Tcl_SetObjResult(interp, resultPtr);
+    Tcl_FreeParse(&parse);
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ParseList --
+ *
+ *	This function parses a Tcl list into a list of ranges.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+ParseList(interp, script, index, length)
+    Tcl_Interp *interp;		/* Current interpreter. */
+    char *script;		/* Script to parse. */
+    int index;			/* Index to the starting point of the 
+				 * script. */
+    int length;			/* Byte length of script be parsed. */
+{
+    Tcl_Obj *resultPtr;
+    int size;
+    char c;
+    CONST char *list, *element, *prevList, *last;
+
+    resultPtr = Tcl_NewListObj(0, NULL);
+    list = script + index;
+    last = list + length;
+
+    for (;;) {
+	prevList = list;
+	if (TclFindElement(interp, list, length, &element, &list,
+		&size, NULL) != TCL_OK) {
+	    Tcl_Obj *objv[4];
+	    Tcl_DecrRefCount(resultPtr);
+	    objv[0] = Tcl_NewStringObj("PARSE", 5);
+	    objv[1] = Tcl_NewStringObj("list", -1);
+	    objv[2] = Tcl_NewIntObj(list - script);
+	    objv[3] = Tcl_GetObjResult(interp);
+	    Tcl_SetObjErrorCode(interp, Tcl_NewListObj(4, objv));
+	    return TCL_ERROR;
+	}
+	length -= (list - prevList);
+	if (element >= last) {
+	    break;
+	}
+
+	/*
+	 * Check to see if this element was in quotes or braces.
+	 * If it is, ensure that the range includes the quotes/braces
+	 * so the parser can make decisions based on this fact.
+	 */
+
+	if (element > script) {
+	    c = *(element - 1);
+	} else {
+	    c = 0;
+	}
+	if (c == '{' || c == '"') {
+	    element--;
+	    size += 2;
+	}
+	Tcl_ListObjAppendElement(interp, resultPtr,
+		ParseMakeRange(script, (char *)element, size));
+    }
+
+    Tcl_SetObjResult(interp, resultPtr);
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ParseVarName --
+ *
+ *	This function parses a Tcl braced word into a tree representation.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+ParseVarName(interp, script, index, length)
+    Tcl_Interp *interp;		/* Current interpreter. */
+    char *script;		/* Script to parse. */
+    int index;			/* Index to the starting point of the 
+				 * script. */
+    int length;			/* Byte length of script be parsed. */
+{
+    Tcl_Obj *resultPtr;
+    Tcl_Parse parse;
+
+    resultPtr = Tcl_GetObjResult(interp);
+    
+    if (Tcl_ParseVarName(interp, script + index, length, &parse, 0)
+	    != TCL_OK) {
+	ParseSetErrorCode(interp, script, &parse);
+	return TCL_ERROR;
+    }
+
+    /*
+     * There is only one top level token, so just return it.
+     */
+
+    ParseMakeTokenList(script, &parse, 0, &resultPtr);
+    Tcl_SetObjResult(interp, resultPtr);
+    Tcl_FreeParse(&parse);
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ParseSetErrorCode --
+ *
+ *	Set the errorCode variable the standard parser error form.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+ParseSetErrorCode(interp, script, parsePtr)
+    Tcl_Interp *interp;		/* Current interpreter. */
+    char *script;		/* Script to parse. */
+    Tcl_Parse *parsePtr;	/* Parse state. */
+{
+    Tcl_Obj *objv[4];
+    char *type;
+
+    switch (parsePtr->errorType) {
+	case TCL_PARSE_QUOTE_EXTRA:
+	    type = "quoteExtra";
+	    break;
+	case TCL_PARSE_BRACE_EXTRA:
+	    type = "braceExtra";
+	    break;
+	case TCL_PARSE_MISSING_BRACE:
+	    type = "missingBrace";
+	    break;
+	case TCL_PARSE_MISSING_BRACKET:
+	    type = "missingBracket";
+	    break;
+	case TCL_PARSE_MISSING_PAREN:
+	    type = "missingParen";
+	    break;
+	case TCL_PARSE_MISSING_QUOTE:
+	    type = "missingQuote";
+	    break;
+	case TCL_PARSE_MISSING_VAR_BRACE:
+	    type = "missingVarBrace";
+	    break;
+	case TCL_PARSE_SYNTAX:
+	    type = "syntax";
+	    break;
+	case TCL_PARSE_BAD_NUMBER:
+	    type = "badNumber";
+	    break;
+	default:
+	    type = "unknown";
+	    break;
+    }
+    objv[0] = Tcl_NewStringObj("PARSE", 5);
+    objv[1] = Tcl_NewStringObj(type, -1);
+    if (parsePtr->term) {
+	objv[2] = Tcl_NewIntObj(parsePtr->term - script);
+    } else {
+	objv[2] = Tcl_NewIntObj(0);
+    }
+    objv[3] = Tcl_GetObjResult(interp);
+    Tcl_SetObjErrorCode(interp, Tcl_NewListObj(4, objv));
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ParseMakeTokenList --
+ *
+ *	Make the list representation of a token.  Each token is represented
+ *	as a list where the first element is a token type, the second
+ *	element is a range, and the third element is a list of
+ *	subtokens.
+ *
+ * Results:
+ *	Returns the next token offset and stores a newly allocated
+ *	list object in the location referred to by resultPtrPtr.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+ParseMakeTokenList(script, parsePtr, index, resultPtrPtr)
+    char *script;		/* Pointer to start of script being parsed. */
+    Tcl_Parse *parsePtr;	/* Parse information. */
+    int index;			/* Index of token to append. */
+    Tcl_Obj **resultPtrPtr;	/* Pointer to location where resulting list
+				 * object is to be stored. */
+{
+    Tcl_Token *tokenPtr = parsePtr->tokenPtr + index;
+    Tcl_Obj *objv[3];
+    int start;
+    char *type;
+
+    switch (tokenPtr->type) {
+	case TCL_TOKEN_WORD:
+	    type = "word";
+	    break;
+        case TCL_TOKEN_EXPAND_WORD:
+            type = "expand";
+	    break;
+	case TCL_TOKEN_SIMPLE_WORD:
+	    type = "simple";
+	    break;
+	case TCL_TOKEN_TEXT:
+	    type = "text";
+	    break;
+	case TCL_TOKEN_BS:
+	    type = "backslash";
+	    break;
+	case TCL_TOKEN_COMMAND:
+	    type = "command";
+	    break;
+	case TCL_TOKEN_VARIABLE:
+	    type = "variable";
+	    break;
+	case TCL_TOKEN_SUB_EXPR:
+	    type = "subexpr";
+	    break;
+	case TCL_TOKEN_OPERATOR:
+	    type = "operator";
+	    break;
+        default:
+	    type = "unknown";
+	    break;
+    }
+    objv[0] = Tcl_NewStringObj(type, -1);
+    objv[1] = ParseMakeRange(script, tokenPtr->start, tokenPtr->size);
+    objv[2] = Tcl_NewListObj(0, NULL);
+    start = index;
+    index++;
+    while (index <= start + tokenPtr->numComponents) {
+	index = ParseMakeTokenList(script, parsePtr, index, resultPtrPtr);
+	Tcl_ListObjAppendElement(NULL, objv[2], *resultPtrPtr);
+    }
+
+    *resultPtrPtr = Tcl_NewListObj(3, objv);
+    return index;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ParseMakeRange --
+ *
+ *	Construct a new range object.
+ *
+ * Results:
+ *	Returns a newly allocated Tcl object.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static Tcl_Obj *
+ParseMakeRange(script, start, length)
+    char *script;		/* Pointer to the first byte of the script. */
+    CONST char *start;		/* Pointer to the start of the range. */
+    int length;			/* The length of the range. */
+{
+    Tcl_Obj *objv[2];
+
+    objv[0] = Tcl_NewIntObj(start-script);
+    objv[1] = Tcl_NewIntObj(length);
+    return Tcl_NewListObj(2, objv);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ParseGetString --
+ *
+ *	Extract the string fron the script within the boundaries of
+ *	byte oriented index and length.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	The interp's result is set.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int 
+ParseGetString(interp, script, index, length)
+    Tcl_Interp *interp;	    /* Current interpreter. */
+    char *script;	    /* Script to parse. */
+    int index;		    /* Index to the starting point of the 
+			     * script. */
+    int length;	    /* Byte length of script be parsed. */ 
+{
+    Tcl_Obj *resultPtr;
+
+    resultPtr = Tcl_GetObjResult(interp);
+    Tcl_SetStringObj(resultPtr, script + index, length);	 
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ParseCharIndex --
+ *
+ *	Converts byte oriented index values into character oriented
+ *	index values.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	The interp's result is set.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int 
+ParseCharIndex(interp, script, index, length)
+    Tcl_Interp *interp;	    /* Current interpreter. */
+    char *script;	    /* Script to parse. */
+    int index;		    /* Index to the starting point of the 
+			     * script. */
+    int length;	    /* Byte length of script be parsed. */ 
+{
+    Tcl_Obj *resultPtr;
+
+    resultPtr = Tcl_GetObjResult(interp);
+    resultPtr = Tcl_NewLongObj(Tcl_NumUtfChars(script, index));
+    Tcl_SetObjResult(interp, resultPtr);
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ParseCharLength --
+ *
+ *	Converts the given byte length into a character count.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	The interp's result is set.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int 
+ParseCharLength(interp, script, index, length)
+    Tcl_Interp *interp;	    /* Current interpreter. */
+    char *script;	    /* Script to parse. */
+    int index;		    /* Index to the starting point of the 
+			     * script. */
+    int length;	    /* Byte length of script be parsed. */ 
+{
+    Tcl_Obj *resultPtr;
+
+    resultPtr = Tcl_GetObjResult(interp);
+    resultPtr = Tcl_NewLongObj(Tcl_NumUtfChars(script+index, length));
+    Tcl_SetObjResult(interp, resultPtr);
+    return TCL_OK;
+;}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ParseCountNewline --
+ *
+ *	Count the number of newlines between a range of characters
+ *	in a script.  If two ranges are passed to this function, 
+ *	calculate the number of newlines from the beginning index of
+ *	the first range up to, but not including, the beginning of 
+ *	the second range.  If one range is passed in, count the 
+ *	number of newlines from the beginning of the first range 
+ *	through the last character in the range.
+ *
+ *	It is assumed that the indices and lengths are within the
+ *	boundaries of the script.  No error checking is done to
+ *	verify this.  Use the ParseGetIndexAndRange to validate
+ *	the data.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	The interp's result is set to the number of newlines counted.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int 
+ParseCountNewline(interp, script, scriptLength, rangePtr1, rangePtr2)
+    Tcl_Interp *interp;	    /* Current interpreter. */
+    char *script;	    /* Script to parse. */
+    int scriptLength;
+    Tcl_Obj *rangePtr1;	    /* Begin counting newlines with this range. */
+    Tcl_Obj *rangePtr2;	    /* Possibly NULL, otherwise used to terminate
+			     * newline counting */
+{
+    Tcl_Obj *resultPtr;
+    char *subStr;
+    char *endStr;
+    int offset, index1, index2;
+    int  length, length1, length2;
+    int  listLen1, listLen2;
+    int  numNewline;
+
+    if (Tcl_ListObjLength(interp, rangePtr1, &listLen1) != TCL_OK) {
+	return TCL_ERROR;
+    }
+    if (ParseGetIndexAndLength(interp, rangePtr1, scriptLength,  
+	    &index1, &length1) != TCL_OK) {
+        return TCL_ERROR;	
+    }
+    if (rangePtr2 != NULL) {
+	if (Tcl_ListObjLength(interp, rangePtr2, &listLen2) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	if (ParseGetIndexAndLength(interp, rangePtr2, scriptLength,  
+	        &index2, &length2) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+    } else {
+	listLen2 = 0;
+    }
+
+    if ((listLen1 == 0) && (listLen2 == 2)) {
+	/*
+	 * Counting from the beginning of the file to 
+	 * the beginning of the second range.
+	 *
+	 * example: parse count script {} r2
+	 */
+	
+	offset = 0;
+	length = index2;
+    } else if ((listLen1 == 2) && (listLen2 == 2)) {
+	/*
+	 * Counting from the beginning of the first  
+	 * range to the beginning of the second range.
+	 *
+	 * example: parse count script r1 r2
+	 */
+	
+	offset = index1;
+	length = (index2 - offset);
+    } else {
+	/*
+	 * Counting from the beginning of the first  
+	 * range to the end of the first range.  If
+	 * the arg passed was an empty string it 
+	 * will count the whole script.
+	 *
+	 * example: parse count script {}
+	 *          parse count script r1
+	 */
+
+	offset = index1;
+	length = length1;
+    }
+
+    subStr = (script + offset);
+    endStr = (subStr + length);
+    numNewline = 0;
+    while (subStr < endStr) {
+	if (*subStr == '\n') {
+	    numNewline++;
+	}
+	subStr++;
+    }
+    
+    resultPtr = Tcl_GetObjResult(interp);
+    resultPtr = Tcl_NewIntObj(numNewline);
+    Tcl_SetObjResult(interp, resultPtr);
+ 
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ParseGetIndexAndLength --
+ *
+ *	Extract the index and length from a Tcl Object.  If the 
+ *	Tcl Object does not contain data, return the beginning
+ *	of the script as the index and the length of the script
+ *	for the length.  If the data in the script is out of the
+ *	scripts range (e.g. < 0 or > scriptLength,) and scriptLen 
+ *      is >= 0, set the value to the closest point.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	The values are written to the index and length arguments.
+ *	If scriptLen is >= 0, the values will be normalized based
+ *	on the length of the script.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int 
+ParseGetIndexAndLength(interp, rangePtr, scriptLen, indexPtr, lengthPtr)
+    Tcl_Interp *interp;	    /* Current interpreter. */
+    Tcl_Obj    *rangePtr;
+    int scriptLen;	    /* Length of script.  If >= 0, then try 
+			     * to normalize index and length based
+			     * on the length of the script. */
+    int *indexPtr;	    /* Index to the starting point of the 
+			     * script. */
+    int *lengthPtr;	    /* Byte length of script be parsed. */ 
+{
+    Tcl_Obj *itemPtr;
+    int listLen;
+
+    if (Tcl_ListObjLength(interp, rangePtr, &listLen) != TCL_OK) {
+	return TCL_ERROR;
+    }
+    if ((listLen != 0) && (listLen != 2)) {
+	Tcl_SetResult(interp, "invalid range input: incorrect list size", TCL_STATIC);
+	return TCL_ERROR;	
+    }
+    if ((listLen == 0) && (scriptLen < 0)) {
+	Tcl_SetResult(interp, "empty range: no index or length values", 
+		TCL_STATIC);
+	return TCL_ERROR;	
+    }
+    
+    /*
+     * If the range argument is null, then set 'index' to zero
+     * and 'length' to the string length of the script.  Otherwise
+     * extract 'index' and 'length' from the list.  If index or length
+     * is < 0 then set it to 0, if index or length is > then the scripts
+     * length, set it to the end of the script.
+     */
+
+    if (listLen == 0) {
+	*indexPtr = 0;
+	*lengthPtr = scriptLen;
+    } else {
+	int len;
+	char *bytes;
+	if (Tcl_ListObjIndex(interp, rangePtr, 0, &itemPtr) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	if (Tcl_GetIntFromObj(interp, itemPtr, indexPtr) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	if (Tcl_ListObjIndex(interp, rangePtr, 1, &itemPtr) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	bytes = Tcl_GetStringFromObj(itemPtr, &len);
+	if ((*bytes == 'e')
+		&& (strncmp(bytes, "end", (unsigned) len) == 0)) {
+	    *lengthPtr = scriptLen;
+	} else if (Tcl_GetIntFromObj(interp, itemPtr, lengthPtr) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	if (scriptLen >= 0) {
+	    if (*indexPtr < 0) {
+		*indexPtr = 0;
+	    }
+	    if (*lengthPtr < 0) {
+		*lengthPtr = 0;
+	    }
+	    if (*indexPtr >= scriptLen) {
+		*indexPtr = scriptLen;
+	    }
+	    if (*indexPtr + *lengthPtr >= scriptLen) {
+		*lengthPtr = scriptLen - *indexPtr;
+	    }
+	}
+    }
+    return TCL_OK;
+}
diff --git a/parser/tclparser.dll b/parser/tclparser.dll
new file mode 100644
index 0000000000000000000000000000000000000000..31f8eb3ad1316d6f590e88e2ebc4942b56843b55
GIT binary patch
literal 17920
zcmeHv4|o&TmG8AJg8+d<Vkb^&HcC;lrZMh}{Qs}a9|b}oalj@d&>Gp6LB#(mjj##i
zVMo@&>_n`#B?)iaW^vQq(r=qC?c)JW+QeXkAxj$v*x<%lmZVN9N6umz7W{>5^?v8h
zNS47gN%wu<d;Pvla%b*6_uO;NJ?GqW?%a`C@mP>0F~)Q#kqBdl@uaJq-~afn9o@6;
zdTACrFzr`&A5K{QtGg>Vx;*9<ck>3fqtRUJXliPf%r#E4+uLMzHJKMbw94GrT<6T1
zIdi&2BVA!<Y<a>ow(CGmO_bXOHf!#Tgv2}9R{&XvLc*n>m{7`5Smq{PPgJ`S03j59
zb>oi4_x3VAFUHL3I2u6Xaq&kBW51$CJNU;26X3dQKVuc7pqpH}y^N(z(%0Y4*zQT-
zQBaoTY?IJ9n}Hh%M034Pj`gf!eO8@Aa-eG)3ZFaX%(AF4ewDNJ-C1rGu{#;?3X~}*
z!Z;4q%9&7}Rpaqcy_e>+o@zH<?L^P1(&IX60S@uan~2Nlxl}x^!*=u&-+~+Py0aFo
ztR!eA-GV4YuZ$Yw7wC0oNex^+GlBP_5MDV-+{N+S&W7e%%{KedNxEAYhlDEdu7gbM
z|Dwg%D&I(2pU%<_U4+)a7v&yVX9=yI!<c{Yg?+V|n_l<<Zqm#?z6N}~X=3-<9y|`y
zqFdV&d}K8!n3PJ3#edrC?qcgRH~G7byHe5Z3nhqyO0K>GL<k->1~xPB3V~GQP2Y&_
zC88k@j2eHM`eQKhcYELI+K-BFEYaBcTl4|>E)wkGUm`FOvai>)_8Zkl4NSfg_yvG~
ze4N00yhC+ev<}59${L+gN=(DIgI{5fvD1K|QNHKER~`k+IU39J;-JPf!Pt2>FnJ4e
z=)44S<6XC-%RgxB{1<}mUP<Cg>6mv$-(rg{5kR@pqDR{-r&uEWz7c~jnI@e8kyTxB
zxr1W&aDF5biOJtZIwqB$`4Z@N%g3b!U8HdWbps^#_`<rv^Q}fD2@F3%Bhp`Ze)A<c
z#}YbxFXoj@*kF$uk)oQ|-Iq*yr239zn&(92y-cbco&quIgFCn$hQESFFd*H_Xf~!`
z<|gP%PY+Ir@Iy7=Hazl&NF-{NM+q=U0F2S8V;CNx0xlOxKzbQI4wTq@s~(YGU%g5`
zE}!v@r29|HsT<2PH+i>cjw7uKDe0K>HjAE!Vl<<P?zjhr9x=$r{DV@m?^=>Ki!kJM
z79I6I8tsh-*8Nu`f+6s!MDfGEWa5G;Mtr^LatJQ;^`5{1NQr5E3H$<!B5`AVV+pNK
zhvr5JNUz5Ag+?q~6j<t*cdqYRg13u$<Awd;6V5sO*Ib{3(h@p&`}m|tnI!hl#wi*7
zk3qKU3H_~#a6Nd_<Y14=cKA1>ZA~QZmSD9+8**&;W%LFP(!`_dXC%EZxkYmpTE<vV
z(w)k3ONO%8Vh*hUK6Hi^r|An`ZU{}qbbxCJp9@yW?;(P8wL!n|&l30stAMIgL+x0{
zBRYTgOT<jNjWje1J@D&D>Im=D%SZjErD+&Kqa&wL*_#6Q8BS&FWYj*O|Mi~W_{I6r
zn$r_qqG|zE#jd9X^VM5v4SA<>cMq@aGOb5f`%Y*ah$d}-L3`>8Q{mqrkU<2h^nBf_
zL(0jZF+4q_BRqy@6z^mY1VQ9m?0eFbxIIVXl%eCC3|X9F3Pl7ONETPB44eTMZTKQW
zpf=_N#wb-OzN0$jmcWV;dATJGV^TCBO^ZN^gaH;!LT`o;psS10gVLv~G`}-W^T(Va
zXzGdP1<=%S=CXZMv5)x1^u`?<fvxELogg2%fJr2IZ|Sp#h^u11AlrwAuc8WgveEx@
z)HGrDQa=f6Ai^OK)=w_XtZ`vtV@xz==;mYIg1ajAkiUD&G)<K7tx8o0@)RE3HVqFX
z6xojUkcu({VOV&jQgs2N<{bsR@aU6^qD{FUvj|^rnPn3#LklFTNmYwg0I8GRbAVK2
zAA$(-8%ot^!fP`0&!=l2C2zCOz(R(36}y4F`pjXHXE+4}pf{a#J?r(K#`-Pz370;_
z*KJUksw<PKW&`=sIJ3~zndIqF)9<B`nqhZQUFYA&4XacQK{ps{AlVhj9g{coO&|`}
zbDlRxdIdTdUhpYMZBu}h{wYXycrbUWKPJ=C=|DQojdF9D8VKpdPeD3JNIQWP3~whl
z_Rdi3DN4CXwqFjHlYP8!vdidaVez`v+xRJl3g>_nnaBj6R90MuN1G;B@jpO_@RT6;
zEMM>9wO{8^qhsU%*A<2v65yqy8vh?BBPu_$k>Yoy#YBsq#KUqU+rt6zz_M546l{NQ
zz|V2HVadL5L>>i?f{yCUSHUN`a%pjCgJt`OHg|=S05O~9^W?+IGYybI?IPB3KC=>0
zSM{WkafXpI;exo~6s5S}SQg{nmNxmwxN*ue5@*|@Dj=Ti;M7UkDt^LM$B`mK@zf}A
zj8arcnb)t19EuZ1o}8jep#5#gk7-cMrHvy!B0QWd4InteFpB*$(TrIDs;3wbdK#*S
zhiPQEGOI4A<{KjO#fT~Xc8FeVzr6j$3CM&6TaOTO)La?@4@Z;s>>YO;+I#Xi)X_^$
zrg~h*$ex=yLR8fKAfc=<Ar>aQ5qM^sY664idz3$-!oXMN2K*f12FH5<!Gb$p_|X7Y
zkRj>|u@O;4)k3!u=5=|J8LRW+ykhf;Cf-VI^i51Ps#Han*V{_f+wcN%kP*fHHo1wO
z_66nZ(E$O|$h>NnObM)bn^tpR#Q+`#Wkm`eT84|RJ7ectz^71()PVn4U}*#)O`eWz
z<MvxMsoDtzKoVO6g#aR-f}+W%PEmY@NGGoArcElkPix($wC({;@NG&&hIwzuuW9K#
zN__8x)qPeSv}gZ#5+*eTs!nJ=NRAEWv5<k>1qWfnKO!zr5mpTns@y*hA=5rkY#;Hs
z`O~l&o<CqbSRUDFzZ%vZw_j!LPhQ<BO~L)k-doVeQ}h7k>h46@enAsNTL|bU_l{eJ
ziI9XAQY<r30E?U%u7m>ywW+IqKOy>Y5BK#}M%{bgr@8mxIQNDT_*U>wcJmr&=`*_d
zwsFDKX?$KcN2)O?<!0a5wAROv)t5g^+cgC5bMTLF1uE}SWeF-DQl$))kExQ2$}}K{
zGf}yXDsxepOO-oO$)?I|REnsgM`bZ8QH|fkRfjZ#M7zmVm8#2{D<a%NQUUS7qT#7N
zYf@GU*SqaV`1UxQSWv_Q)xZ<|c~pho=+DuZdZRxFeZ4uVclbsM5S*3r6hwq0@9KEM
zg}W)tH)fJraN9ly=MB==aN9l=Ygqbf_<#7ubkZVhlcgnLw{NUmT8kTXnx&;-M`=6k
zFFjn!U|VTM_+cndA}x|Nworwv(M}bz#ty2GHJ+vlS>su%kTssC3R&ZaR3U5pGgWS8
zjfv{MKy#>|g`<?~##a^J0MPay(Mi+gO(G=O3kvtyO$p&8h>uu?SllLcHO6lz4pTC)
zn>1?bQch8()3#U(jxhsrnLuSEp}*K}dh$nc5(Ic2qy&hdM8StLvy2#R;t}09lA$4U
zuUUcAqmPSong_INE~U9#G<m7PjYkO3M<@jS>!?n2sOUgC7>Z`S3As*nYMLwFMAbLF
zs8>%)Y0m{<Y7+>-8{uneK2u-%cu*VP7fccgI4fVTMcX3!Mm`@qEpw}L(8&g*ozKhD
zH?l^XKriMJs5(VXr4fuv{@Tl?7n%#$&%#?w0VIrg-yu(mZbd7AhKQgIDo4xrWEzv|
zCUByx1WswH#-e#PI%o#xM9B)A1}1Pyi{tb@ga)VCY9f0Rtv>q++>y^t;Yi?i#eM=S
z+-vN!kE+lCIDdFPdI@}o);*hV5Jr)x?xO@h5{5Hl#{j@tw6F))w(OU&MZ+GDg2_<y
zT@~r?vhg4*neNs3?4bl7x&bM+54qphraRGfwB)GybV&2*C{*<k+B?R!UgPdKzFJgU
z(RL9Uq?g1P_PE*&v^lVk0FcXH5)-BQnn3%o7LgA1q!HSi97g<!+FDg)KeW%sdb9D;
z#J1dQ<j@TxpN);Y4J*BmSb$O*tqjw!gicL{ZomWl<tDaUyy;99jt|>Q<Y14<wrEk;
zxpf@<IxgtI=$q(^!igrFdXO@zzJo{4P%dkRc6u}D<r?}U-Oa#}FgoZhfX(K|P}8H+
z4QECjAS!fPG;~I_4dZC1Ru0m0+iK`cfkSV>xksGxG)P)hoxnk$-G($k>5al^3cZ!4
zDU3(pZAMN8UGyT9CYv-D!f{%?_Fol0z%Nm@St>A#ObE!7R)hbFvGez+c9gyT(hHv$
z{j|CQ=mrXZDWwVfF=4sHLJLz_Y^fwYL{=N<;Cu?yt5jOn;B;?`vd&UzJb0fR?!?*o
zt3-V{a6b?Swev*dE2n)&5_}&BzK^FFpF3(icsk*X@!;&v)86-RbZYcJjUjTlAPxBf
z1Erb6g8&rWY4o4L6C;fW@9-T>=p6Khjj!CIk@>4b#HZ4dDW~!iz?C{k(xyz8XBueZ
zzf7mB)XOvJB|uKq;qL1#QICY_{CjF8=GC`^wiNi>P_kC+rqkls`87=yvyUAnk|#~n
zhNcDoRwQh(JN*5=Wa3KX`jUyKS|h$xi}DU?`uJ@0@fBeS$it2}gUpD1L--r4XWv)^
zrbsh(K1CdLd~t`Kp9PoRhf`j1PZzKVCH9?RjS5JIh11E5c&edwu|=Q(Z5S>0K(aJy
z6#<)n83G`k0P_IQ81auqp)njz`Fb<t0el|<648jH7T}8vfNP@%yW{82Krs^?5i^4O
z?C!>av+-c})d4#9?OI<BlTm2D3&;8OLA*~9Bv7HFeNQUY5#EP=y@ro^==%lqk*3V)
zE&#J@5$SGxFfc??zQ^0)1n*_Yx%VqLWA=lWuQzRNk2n}klzRe;5|k7_Vc{#*X!s;P
z9BJ}(rNB_MIzQ@BzmFsnfUF+gO{dc8`pN8Sfgo{y!Ow3?AAG<3WyyH8{{;!XzTQmL
z%iuj+BctsAj_9yLOxf!!DUsB-0g#VHQZLZ6FOqthp2xX0NP~<tIHCh?8cMnt7XMxR
zL&qODlQensYQLOIQcPeLJiPyoR~NtX5CjQdApL0P=gADtFipq06}v7_rRz)9q0N0+
zJ?@ZGht`AC0No7e!qL(Tr_kW@q$4Yu5q30@RGlgn6#Fz5P9!x&ZAVfE+SOxo;=<=^
z;63`#8#p&5)$t2oft1Dg>M)ih!2pu_txWym!1aw~oB^NI0m)2R4wORsaNfw%lZrRt
zdj{FxSK0vS5{a%fy)T(JXsKbFKbv;=#jrddzZTy$Ud{++ZtA#3cj<TaLH?O75g+h+
zbSlvMVLUeZa|W$<(iN>0w7K)9K&J2y>+yXr{%b{$@O9iVHGksm=;ZMvdAkH?21NDv
z-p7Lp5f7}hSfJEBP^z!H9IOnXZX73ae(ThiXg-cQp%V#xp;p|&GvlZS)$g-{lG_F&
zBC7BD4M;1c+t5M?enb~krWYP*ouxdXOL|COc*6M9&(QDdNx%tz;YZ$gL0Rqz72vQ8
zAH4dEodYCT`er4U2psusV#0a(etjRN4(1E7jYwKzknh*QV^e54=>U`Mx(HiYoTdZ0
zNNPHF10)Km5tGRXRD9xl_nMUF3zhpWyeee@W=@(zBZx$~Mgq_jeDC82?Wt*;f(aB-
zeaSSj1YfU!wbdhD8D55k9Z4M`-_u$2tKg&%AoMKWVaBBZU1f<L{bwnKQU7Lo$HC`B
zzzzTwsz+OOt1b!jY5n)8ZLA-jF_-rxQx91xv<C_Z=*j~+|6ibaB&0iXK^OWq)X~SK
z1B}h<g;MVFT^N0VW_Gx{Ds$6(y7|VY8h3pM2)?ly#$DAQ*F|82L4N?yu3oLtj)qct
z0<D)%5h!Bp%m?zzgsd#m!>f({5deHWhK_3l^gN&>84s?~D_eDeo%Dkl1th@lV^aXx
zk=Aanv2zxU_}Fahr0u-#W4*D{jtcD}p@=#tFZ6YM1r0ba^T5TKY1G59eC5$8#l9YW
z(knzY@K<yX?Z7A%QRZOxZ@S1#;-J5K`^@k^!@r8>5a7ul1WML&y99E6i5aqlQN@H@
zeLk?_RLp_s@DZVYg6pV<Z~^-XS{JHeb%#;MMu=V!@cMCz570a%9Ejy_Rb$y$3VzBr
z%GY%Mlg7@U!`{PpqisC&9M?`iQW!pu`><m{o;EJ+SM0s>UZef~DS0&XLwsvB9<raR
zmv>NqOzFm_b`T*W5juFAe6Hhl5Q(&xfxx-((JmT&(0*#?l<+Ykdm?Fy+@}(L5M6Rv
z_$SIta+8Eh$^spq)dIbOZ<28id+ZtzF;Tz-veW-Yo3DE{AEg7n6BHt;XWL==Iqj%Z
zs+n)X(osr>07PcYK$=sMNKyZaPWgD`98xLvev)2UL|@h;{mNRsf6zM^qxJ~~0u^yr
zO=X)|S0_l*H&<<aP&|X_bhJ&xFt`&7rD1&_e)LESv5d_cF*ykhi@Zpu%GjleD05k(
zIE(a=RN^UibFRqOhoR6&_;SpiJbsc4NTX)RVMMg1pQuFrGbTD$M5@LGK6bm3SlHv8
z9)3{K7yd@d!2WWf9^)^?2E^t%fu6EdFE8U+s0e3@*CU7D0F@VriQFH4E4ClOL}`U~
zZihD9IBrVv&eZf~^nVYqScd5d#^B!uoHsDid!DNYVQ99phBN;q_NV?qdBA(IFPYc@
z8PSIHz-v+K_p9~_KOfVVMqj#J#U}fVb60<#qdLx*HuPNRM_A3nk3#J<pU`)xRg0FI
zW|GQFItu7Vd{Qz}AKofD+R|nuU=xQOTo3sde4)OhV8vrvfB4thMpw&+t5+ez8)y%d
zw6er_$UVh)Xkm)~N?>tfn)D^{WKgLv6u#9uHK{^hc*bp@SB373!b{!|Z2S$PulYOP
zUj)32gaX)$il=dO*E*xVqm&jWIM0B;%KhA9gLnhNa=9P!Lz}<rDnZM5XlDu@FelYF
zP6@2jr};mWUK6i`X9Ru66MQ`xh5sSl3$NDGn=*b}p_9`sp*z6}4s)J}zon6{$GKy=
zczUhe&wpY9eTgT><w%lG^sHW`O3;fy0ST6I2{3&_AgJ<hCs{heYQsH+6oD1_W$~n%
ze@Gu^+?qaaiPOhP`2;i)l#lRd%-&*m9DnR#wfU>uFKY8|p8}rh{&ux^B{pCcUbzg?
zOnH<DYi3i&Pf^Fe$Hz~Q+<53QRpvpdPdr^8yi)#`W@)Pbq;#8a7`qB?zPG%?;uTJ{
zK8Rle5&3a>Psi9xNpgRW%I{e?oxhvcjrM+k$MNIm2mg!emwx~AIrMA(RQ<x=J_3EE
z+_Lr?SNo5I?h236dU#}_!r;e}fo4>##Y0v8Hxbt%&HJjpw0ztSr33he@z54{{lh8#
zNT70dnsh{2W+*%X6EDMt%zX<v;L(i2KfvX=&Z>L3qk0YDi^Sg-hDuYErATAmsc;TN
zwsZc$?IESbu(snkd67H{VPbp2hbv0y=cWNz)}7ihOm*KhHlLonqcuG52mosy#Sl6p
z;QM53lcNN#Z%6J~hm;ZwM($aoJu9_mh4x&oJ(p_F#oDu6dzNU=9POE@Ju|eYg+F8G
z75F{S@Q%S~_z7YmNA}~rjlv$)>G{R=*)`DOaC@9?1kEf#5GNT%Un`8*5~rZhN6B<N
z??L%0N+HT(lu3rgK>e@{*@Z4TnWwkapW>A?hVVt@|EUHVTs0eNH_aFGvg#TdSoN~a
z)hnGFTpr2kUew_5c%1ZO?1C(jaX(?rEt0Fb$?R}%Fx%*sm6c`FfXpMgT}^<yn(CZw
z<_2fe25F-$3Uxc0HaI6V%r*|QfqvEPnVaHE@@*5_Lur|t&I2b2&kU3mDDR-SQJzEj
zh1RZEuyU21H9&gyO>eX0w6{ra2di;AYPD*k%j1EJ3kkyF8jm}rXtToMb~Z&D4-=JW
zW3|Jr4)knkk{oTU#!>g6x3LC`$J_LHQ*&z*OEzb2I&fF!reC5QM|mA(0OcK&4^Tcr
z`2?l4*<Ht+Z7q(bI_7aTwlp{y|7(C6NA2StXniBAZEkF&-pvlT%Ta@VkGBQ`+|aet
z?U0(?%+<8n(cr2xb0y-BD_Xo#5gxV8Znv{mGLsU_9@i62axQ0Mi?l_>EHXDW1C1=y
z?ADBA1|=^H?F2*41YDaOjZU_~3H_1XP*JVRYBxe68qRB~ks+<ONosPoHn^HNKUWjn
zr^W5W-Ry-6nH}`!ADB~%Lvmp@W{>2p@t7N(pw{H_G_uOt29lFu`)XdFxv4)BHin&A
z=eOqN&>xRTu12T1-r;KSx}8PS*@C({x6|V>-_v5==<x6vH99sp=X)@7xF<84SG(Mj
z*U|8>*XiEE2RiG_^_cKIb>^Ba5=kVP9Wg4zIyR=l4Vy!Q#15lcUD8H#E&gc5EVSLz
zMtD`KwaqOar?;-z%>NDn^TM*gAHGP<wapFY%}%$60Qb~oP3N?4KBmT{+9`^=WYMA`
zbH<VftLB+=v$C^9vsDmtMXQhxI+OL~309Hf_Gj$N15JTw<_ozZ{W-^E<Ng@GFZw>e
z&i<H<{#1QNX~Km6?JN4XS9L8ofdMtVuJe+Cb~(x#6qdo*ew=FS)-$F@F`$@G+~{jZ
z`5Tn)qx=-*2ntb3WJ&n5oMa}|HmKVSo@21ss~>1`NvkLb(9&1?IE+vqXp$-#9BOxk
z<kmnOTWen59qS{uUtFI{110U_=$Czr^`jk(gOztOX6YEmiLccGz71tJ%084=P|l(Z
zp^TwS$0sNYN)Ac|%0`r@Q1+tiL-_^DYbfudjG@q_hYYu&SWpC%0+e!;Whj*>>rm=Z
zT2P)q=|tIu@+=Bn|3AufmMwNRAR8`nyChewqhXbnr!F!(Wy<TptT$naQ(ELjCdX26
zH`gN9v12#F9;jm{<Diur-A+dxfGjBy<Ci-;lHKjbR)M8bdqs1dx52p-yNU+q0><nF
zBjQ>zWo#=!R&Bx7udx#Oc7f-9BtWXM=cuRBRr~lNO7!@|kVxy-h5g49H_YkYq~%V>
z<{QB5+ethbS2*3s!`R!@Iyo`yo;K)KIi;#5Yy}`$oxQEr$v2tc4&5+Gx2nPEY++C7
zDxK~|SCd0>MpeROU1fs@qOGR=3wu^~QzGo3PTLV+EM<4bejbHzu^7u|)z#PmH#a%k
zToT*GsvV7<4b{BCgoJ7rCJb>JSq|#WHH<xzP>sJoe4JSmtF<xrC&9G*ZxS~o)w`Y8
z3AvN%TVZn4o=<Aj`pzU_Cxv|zV{cNeskX6&eUMb`ZQ|65b&i^5x5OUNZLV*@MoX&a
zPTh|C|Hbk(`^pFH%d@RK9D{TUX#c6D(X+YMEk!AT*caEIuLexx@A9+<Z%6s_oy-@K
ze`XEr#kmej1Kz*V@E!a!kNX1g&tC&3#s)BpIl`BPhlCnogRnyg3g?86g=Fzo(JbbP
z>%<Omw|G=MB@T%1iiy?~>zAx|TbEiNvOZ?*u<o?}&YGOFBxhyLnw*9lZ;n4_SI*I#
zf6KX+lay=9ott}K?vmW9+^xBLbNA=Io*T){$Xl29PTs}5)cke%oAL+plM8Px^cTKc
zIIU=DQG3y^i;Tsqi+#mED1N0lT%1s{t>oE~mrDM#q@uL8w5{~1(&tLMO1n$nEPbc6
zy6n4Uua#XWtF=98`-$z4t=o3ecG@;*8?t?9yJCyjm>K^rLjv}b!YpB~Fkh$=wqRcW
zDEw5giw}yAi0eg{=oYt%onk<IR{XB`w)hq6H>`?vpY;{%JJze#`?42gFVAku{=4k`
z*)M0mn>{n9HK#szTkf}Vf1Z0acV?cLw<K?C-p??XwEPG1H{=%;{CmNF6ntF33U4V~
zT3A=uRM=Lyukcu5xbTz0{Gx}7Tt!_)|EuWLqBo1)FZz9vq4@4%Yw^<J`r@s{PZ#el
z{%-L<75}>UOz~K;zT}RQzbKhoa$kv1Qc$v><ZC4lmpoSTc*&b3zb#2D)tAmG^_T7~
z{bgyW^h#-dnX}AY_FUP4vLj`0mi=2<xa_~mX4~$z72B$9-?VMEZMA*N_V>0IZ9lWU
zYCCIt&la{_w$Z-{K|gT3Q^*vo!ZM*kSSvV$jnIxycv0vT&I^}>TVVHc@d0s<_!HRu
zE%Ac*zIajmPcg%qWnEzPT05<>^;_2eY5l(SnDw{TVe3U}O7@-5*OKhY>@C@UoBe$D
zzU-dtUu6$upU=LOeJ%UeoIBtVmvSOGQ*vkII&(d_9k~iLxhMC%+)MC@DS5X+pSC=E
z-txR>^1AX~%sZBM2AU1${XTCjZ%Mu*zd7HVzcv3r{`vfc1<MLn7Ccr^Q?RMPUGPM~
zQw4ur@U4QsEBJmvZviW3jDB-s7A!&r<|ha_LV-{slnd(x`ZqC_qOVifDLf5N*e&c4
zzANk%ejw}<ek|-44hV;ZUkKgMzzJcwSRq!5YvB3o#X51L*dVruPg{f5-Bu6?s{dSv
YK}ZwQp-Z+`ZR-TRU=U0M`LnwI5B_o;GXMYp

literal 0
HcmV?d00001

diff --git a/parser/tclparser.so b/parser/tclparser.so
new file mode 100644
index 0000000000000000000000000000000000000000..e0c0e99888cff162572577405bfc87d7bce03e57
GIT binary patch
literal 14496
zcmeHOe{@vUoqv-s5F(I(AmK-KKoF>P3`kfIkpX=AKvEHz%I<<;NCuLUOycAXf@?~2
z$jaNtwCR?d#vZ#TTRmOe<*Ye-iYMBNBch2OS_jcK+qLJU745{NHEyd7R-OHP@4erb
znMXi(_nbZZhY#NSzWcr3U-x^z_j`ZL%K?4kt$7}g##g>}vqq(%u@Vzd6@81<3qU|y
zu8qTUmNrw+dPk}*c&l9~Q4BTBClI7VsPM~r%`fo`JM$#IS3%~ZBJq_dz7oa9FsYit
zut18@#sJdYqw3voo}yz&v~+EH+pMDZ9rH!;0(eBCHHOT0C-{^L6~(1Nv8vvz^l2CI
zi^l#?P&G%iZ7O8s<G$^yLG6*BK6d#Xug?8hpkVOG%U}6Y;QUt_Do6#@kH^jaKa}!$
zG;d%$;V#2H3HMt4jlmzk_4f}fTzCGO-g~#seme2~q=B>VQPm}{d`LdzYIGYori{Wh
z8#v!6_=CWWMo;#RMjyHee)&c4n}MH;+kO2L5XIVbt+UjZQ}v9%muS5%d<^(0+5~NA
zoFumt*S{)yw;bx<DWmx33W1-f^|_6zsMuXsAE{_GLs7G$LaV5W)R<buE&#1!{g(2I
zs&F*CyQa|$N4J!(tF4cOw}f`qhGpI8H5HZnLL?wmTXR1MH|(w0tR$?f4K+4~8?`N!
zwGE+YV>nu|UT7ojm3t~GtM^pw3f0tVjb=1bS=XS|*6ghGH`e=?X%*qBkQve{Dt0zD
zN?U=7RB5+uT)%c*#S;Hg=WU6<OuC2ym!goaJjCJ1Kf-u``#vC#hp9C+6N&ygg^SIs
zL8#_wFB36cYW(v!PpbYXaN(O3KA`%M>AAeah2J?(im!Iz-%|Jn7e1}<`&{^cxLV3-
zcHxH<{UI0ryu!D-@cAnLw7c*V6~4oTFH!j3>wUri8kX#JLiA<fy@EnM(pmWIp*)m@
zSFRKc!&!LtDOHpxdx%!0Dnakd!jBOc`7q*x1%~Y{U*yw_mZa%TuLItQpDK7EiwLio
zvdtjL%-@1%(NzJwQMsCk`uj4t=5L@frHlTQD1Wrjr|oLZ%r69fSF4d&^)z0LgqJ|j
zSTt-{ZyWL9NqeV3{Y#)F_2ai^`gRpvb&IBLe}S~@@)uookaU1?)qcTW7M1*;694m`
z<{Q?K@qBu<;d#k8^Ql<^Vc%B5CP-nD-z~3s)gs8zVhfD;s@-6KN!Huu1jAnS1C-J_
znvgc|*#44N1EJ>+7uvJ_8W<g4t;H_uzXz1kZs;Gc^!Jm<Olo_70JZcEUl$uz)39Od
z!<669sIqf20j%!yp%TEBWNcg)xp3faI7+m`)(pG37!hRHO~Y%ti0f&37>Q|11StC<
zBxF*c50PG?4-^wIll^)D(226M0GZUwFOVU3!IG`8q|2~komTLeVU>4O8TOd@3rVD<
zrxz#VO~>*MEQZv}SZed80#w?;4hZiw5)+p~?+G$ClM*)fpCc<1-d~bFVRq|y#SlM<
z7+WIvDBKdkp3Q57c^ebnJcxN3lBq?v2^$f8#fXJMDfOFD>On{9R_GLF#80A~Q;bCU
z>xT6+!}<lBVCj9f-V+}#D0=u#@L5SCF|`G<g<Uf=%^s6yRFbcLih|)uW%|(0{MeLk
z{WMY8`s<dS>i-C@z<Y~YDEonWoTEH2q8y>N1Wh?@*yWvu^=c+HV)HLC^1zm&01=+Z
zV)IG1)F^C^fz8%Ww<PzER|XASZU;}psud?67!MFndn_Ggs3MXS**tKE9ef>Ji%tT+
z;$%~Ri&hG48K5pS96MZHm_X2-pe(^%I7b>jof+Dz$HAmv3i6H09>i^*;dx#F@_2W;
zZxR}6odgCh_&G3{vm!+Md*LUzaEwX%d*-trT>7te>;Ffv!G6f=FycvgxYS5Ap})%E
zWxaE~g{0A)K8kh9h_55WqWXLr-gElA5DJ_=|71Fhr9QXIQ*f(c$NHq<-RX5;?4L)H
zE~si5gR1ePRy~NY?f*U8cOloek=y&vj#_mqeAZ818ik9hXcoS(>hdB~J%p;(f&CPl
zu}Q*7cEE?A?;W_AoE<APy7gYrXajz@{myw8ar@I){A73gz;z=IFA(l;>SgaJpWg`e
z17lmokTmS==_=!f*&<tD#_)WU$pAOZx#hvZqZCHgv(=xV!aBYKz-rq@&%{<dU75yi
zp(+}db_<cBiwvu!ncfoK#MRt}tym=+i9`qRb{mN??BjyS7JAlOJtCusVfbYu(ME)Z
zo!B8ji!?>V?B(b+nOY9ZXkX;$2%y&tyG;^{eA03V{M{`kp5#}UDC8piZijX6%~jU5
zH&B4I9hEwzYS|b$PP)i=8Yc;o2Psko*^@atU_jL4Iif}kC;Oifs->jJr6fVlwj4Qj
zTbDGcQ>qo-kb>r4Qjpz79CnLfZ<k%tN-`4OkLF}I8txK!TlUzZlLqq6NxOx5Xc6Af
z5>=n2`-#F!xC1J_%PN|wqfSusDHGE)XSK9L^1x<<!alOFjk?B29MAE2clt_nvL(6=
z;*2@U;%4e5SWKKSj3i;|P@?UY9+X!KrUM;do9t#2^!9Ptg$db($on9D$Hy8dVLIKc
zB1uh73GZ_bSwKXy3{sl8C?9|?cVHd;5cWNIibm64Zx<7{@!()H1+De0wEZ~w)@nOU
zPZ3(#V{3SE5~kfgqEkk<<do5Ulsu5|E^ugez%E<JGb&%<zD+Eh40m^e)^3xH7wW}O
zTY#ZPH6#73yecv^a;F$-0}+r(Wyd9T3t4VhXH;x=r)$TeT?y}_SNY%v{BKsC6kK+j
zBb5wKcw-Kk@}!WO<;mDEQq)pTQTKe1$&93@cJj6L>^>~Zke(U<thQQuCaUqwb|Dr*
zP*&h5yD%K}4!ebTW&R>rVzB6~h8=9hI46W0Kl)K**;ZuhPKbQ*N^WLSbbPFJW1{@<
z#smlw<?Tp8#Aizrv1Ix>g}zu86&<|71M6vmwDc~(E?Y|&pbd6eh4Ep}ftiqgw<8_<
zIuHl3(35^!<<z85a{>_or>`0}S&l88T01kB1co3)R=tajAq_vh2PA*`l23I~r<9Lo
zok6sS<}W&9Sg)wn7<JVv4zWtF((fVw^<EG>!36C)Xz(Pw?Tiq^-$(?LSX?}ZSP~W>
zrL;&9YQX^$wEq9VL%AD{7v=;z4Pgt?kn9IrZ#P!zM~mVIsoA2`LMHE>NQI)O0+~a)
zJuv1a-PW3$?7uO`;yE{l{R#N6^g`p?ZT)aOnP=&TVdnd@l^1084<5#nt{uh+FUTaD
zq#;L1u)M>uS|<Je_YnW+Z12CY6czA9*(Td3^Tw#DA@QFSA3W#&57NR?N3H6WQPM)O
zL(}lzNDFe4^4ZD3MkjpU<Zy?asSnIj9=~*Q*y@mduH>-h{gLDlAFRf{=qUC@7+=A5
zcP>CA*n!gc@c5#KDT(B)HP>SC=Bzc#P!MZP^ze^xkV1oXz(nESxUd_APA>dacA-3*
zERbEeA-ix53ddQ%3>2Q^!UPnKsRD(VF_YbvJ?N)^LX2n{^z(B_C}W%u17D3}TKXfj
z1Dj}*UJCjTX0S+=0Z_YnlN@#(a@cVS7?=(E7jx*JgYTqnN)S&tbutu#aQ{elu(_7A
z!~Kl7Sav|7ReKR6VV#z$a$}37>et@Gu!*0l=IJy(xZ@JrV46T_XJZ>aTR%n_-bxvs
zBqjLg`|=G>4|=s16uq_<A1*FBm_V!Wa^ULtaGtphj{}sE&E@?^Ma391h@Gjqz5fwW
z44C)FhXX|7Gb{UBfLqm!hk5TRO4?@8Kn%W_HbKNrO2p1YE>P@@;{wHwhYJ)t=V@(0
zdq0Yu54k|G^F9|Sc7DeNik&nUD0XPHlK_gH2_@Xo6gvovR8C;@iRN!ACICNSn~zCJ
z=Dt&C45XwXq<cCG8D#<;f^V^_jqAreuo#)r#({(#gWE||clxeRF*C#c32(C_ra{`$
zLHmEZd}w45C(W6P{i-LmQa{%8B-qwFY@{92NgquoI3D2XMDH-HV(MX>njl(k;#I@K
z-*IBVc}W0)(u=&1vVy0x(}G-Oy?q6@P>zT46kOGtGZ6Y<%848@Y(iC_laqen)McBA
z#7Ab@x$Bv44rW<a3d_>4tj`L*X_eEAdbcA=jVM&h5jBk36;5plq}#za#ZnJm!8(tO
zw#$dbc}5phYrJZT4=&GgfK^V*fT3yJXr%`Jk!q+tuW@aAQn=mwJR_P@I2f{NPajNC
ztPoGT*b1q5`L07L7lGwz;Y~#=?7}Esu0}DPW?g99U5<>=j4R_>Hf|mxq;WVNp!IJM
z<Nb^s?4f)@EBzcR-=E6O|2$U0;AVIbxhd9R1s}zcTkA$kKXhRzea{hlNQNu?6l+DV
zfHmio>F-2!(<!VNe_}(Tpwf@39s5J59XTbrhiKzXhct5=y5=w3Dk#7XjiO?KRDsSe
zPf8V_a#UO;RZJGMc>kXfE$U249Ad?$<3I{YFjmy9zfPfK>q$DQxDK_1o}sEI+xkx|
z9Y<KnYw7r{cVGe|PN9TTFR`@NJLI~$j}i@?70^)>60)A|*54%Q15*iC^pti}VQfrX
zf74^c^*)cFTdAj`zd^GDmve`?Cz>JD&UI>O2xC~NSf;wMPMzxNA;bpyBWHz{n>+^6
zSwnPF*4RPMC(-j=7xsL|6t++GJhE#HO~shb?fH2$ZuLHN?{WZ|ZAxKe$YI|kHlgLc
za&wg^n@)Qx5+Qr)ZE7E}$CkyLPHX##dEP~t3v-!|I?N?-ZnB$vui>qWvRQHeK~zKB
z8<V*y%>og`2&Se`3YB}l?DNtslBvUC3J}7M(XdaB)_zIf;Lwkz1T@H;BSYXlvNPdb
z=`d{-N?=){{2X^B0t#KL4^bS2V+(Bk9If7gOO!1VYx(YU-fuG*xb8Bi%{V?wc+VAc
zgR^Y!%C=pd?C&9$@7n?Hq>TZ(zmVRtyvVpN2M4;9`soM83l?&+c%diuel*RUeqgdd
zA!u<7On9qUCP~+XcK16RlUCEm@urWj|Hec-R~%5Lc?FX?X>cu##AJ-2*R2nW4)4}`
z1Qhdrpag!y2DK@rnY5Qm+1jdCpLy(Ka~=wqkftre<_&YKD0K&LHiM-<J^IgzJ^-%`
z841iPHg;`xQx_lS!SC0CSFBTqp<q~x6-v%Wz==aot?1wcDWjA6u3H}@xdWsaowf;^
zwjgz8(TOCM5_wqDwj_&=B#WL(dh|h}LEXV*>`c6A&{Nc6ffdMMNa_O=5(f&ANQRtj
zA{k69JBXKBL^)^qN%P+&hNRJsk+4!}0_zt<p&v-uOw~m7V-Ac*SeEHnkEmmyemd|P
zSaE6kX@VYx=6WSAThL=z-p!LJBE7c@5GbIP`#O|Yav6s#mbXk2UE?4@Xn7Y%Z1D)T
z7}yyo4$LvSy&q5XK@H6A_MRVk{g7Ybz?WaZoLqn@&-oc~xqq=He&g2a8_b&eh%Xe~
z?ORO`zu&)FA?b(inh5YUk*e@MUu`(D+pJ#A*k~xSJDgMStrob|u;n`#mD%@lgnD*)
z5b3x8_tm&>#{HMLU&L+V{ub_kR^?4=Hs7V=hxSHOyEj&EhV^}BG^Fi}hAP!-T}@*n
zY+OqiEvv96Y;ti^C>oA%;ZBmmg|CI8lCg1r#0>4zc803H8mrqGj%u;Uo=E+D5lzR&
zK7|eGuW-MM`%k#X05=);mAJ3Py&U&__0cLVyssgIAN?C^>KgC~f*IatLSp5fMtoLK
ztyR|7)lu!<P_#yTqR<%I35F<q9gc>~`l#r`n#f*!mr&&sj`Y<;8e-;+0G0L8Xt>h!
zkt2MK^xcBG!gUSieo1|!FH#Ru>Z$su>MS3m#qdP~eTyKJL3<=r7uI%%;YaE}yvSbG
zDyv}`v5Pm^*|0hmF(cvoYHK1wXH5iOS~Nt%c=}@aR>BvG2=nS1LS_v<yzn)ev7L>+
zx-g_gY8vb4TM9DOGb?}P5kQ=5X`6nX$#ep?{w9;@1)T9#CPP^)hM4hT{Jr)rc7=db
zv8t{H?EgKEW&jrtfe&yF{M`$<;g8@0JO@Zi=M6YjTn_kKz#V`IoYx)#e0VsMp+nnQ
zf6ioj0B-_J1JX5B0?l*(X3ev&*fVRwxB}8O5BS-*+wo(1DbY+SzI9T`hN8>vD`?hM
z&s_QC8|KX=G|}9GyAy4qbfvACRQ$Jj>n4uPI|xZqP8HBI(AI6poKC$S&(GgHM$ix&
z={t<O9OGm=?S)v50lH234jt+H5$=cjGnuup)1k{><sl-HL#w;T;lnqmjoET~@^a*S
zjOshFry^fFbouKXIkSP^58n@E*OT4v2of-<_M?6c`esqKzWjMY8QEKf`VHu_?-2vr
zlh-C}p?X@QoI?GsocfTcr}jLK`oceCGT+axhaGv}ahfCAeHwHJK=(s8-J>IPr0<WQ
z`vi0!0Xp{Ne;^t~^;6M~Um%8#<h18oPJ5ODe>-AoPPU$HQU~#GLH$P5-;%?>dc^s}
z_r>*v2fpyY7asV+1OG2Pz~4*q_mONAO%Zg7xd(89C~403y*RWN7k{@pLzVe^%vq`|
z_E>nI$z{J!ywQ9?7uSFAX{MgaV$KD`CRbeTv?joX&A+%xX>P%VU+%^AhJrXM7FUUa
zicQnh_lAm16KfjK@cIWQ6yln$;8vxG@kv^{;9@)5m1A&nC@$8A&6TjfRncRIC(7(c
zEE7aIqUz79GW%7D`#%T#-Mm}zOUe&FXUDq<R5_shE594o7W+#}7iW|5ceMQ7EPp4<
z-^KEGu>9RCf9J~IweokYEc3Q?>u&Td4DQ70JmxF&FZGvRw=5<~i@&jWnZI<YfANw<
zvck8dbn&v%Wu+@L$%N117x|X@SNIVF{>Eyo{>{)%%^$(O$iF)h^Y4t+)K*<rQ>BSg
zHSJyeRr@22`|Bh$qq1giINFGvV@{z0b<uEbh#1scL#?U##aG*Yy!v<7qbRmUe(@2v
zKUyz7o%V;TD|SV(HL0ksf)FlA){0Ox8rrW34u1c7CCH#AR99088|qCG4-9>W?Z;=>
znxA%D;fTpD`(HsCS2PxQ{Pd`RW=QMQ>`R5WgSrxL*pAdQKaX#QHz`UUuRP9Jz(Tx`
z4b0EupCRp&=pwyD!~8rhX}ptc=I4CEkn;yf#Kq&4%ggaXW10DR{4%8W(Z%*N9YY;;
zlpDCr`GFzlBeI`#v;BA#*A_gvZG_-_#E|n5>t}v$|2>L-EivQb{Kk;=6aN*s-Tc+S
zkzJey`0qOya$X0CxZM3;32ZihrxL`F^(%JgyZ>T^h`9Ls6hA|zV}7=u%lEnX`R|$>
z$P<-faLa3Q@$-Dgkmmu`=Wc&o@pJzV&6Si4>$pM*aNBRY_}zbpbVTtnaO<bvc**~)
zW_Z4&WN31Q65!VV81VRpz=?03-}&#8-1P49li)4N;&=Wo!w)1bH@&<3W6+TO6rXez
z`+W)u@R|HckWt7mKhJmk_hU&Cj*I=q`Z*5hbShgv|2;+T^@2@XD1q~2eugi*_<23T
z3z5&_f6c|u^KGD1s%&sH%NL)k+>0{V!tLk3OX^ho7t_yTeuWomzanQe{!U81-s)iF
Zi*l#nAxyUKvPnNw{O@EV6@519zW}P@=wko?

literal 0
HcmV?d00001


From be04a910cba4e606bb96226d4278cbb4460b08b6 Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Wed, 6 Jul 2022 18:15:38 +0200
Subject: [PATCH 10/39] Update README.md

---
 lib/README.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/lib/README.md b/lib/README.md
index e6215ad..01dabb0 100644
--- a/lib/README.md
+++ b/lib/README.md
@@ -6,7 +6,11 @@ The following packages are required for use with C/Tcl.
 JTcl does not require any external packages, as the required
 packages 'hyde' and 'parser' are included in the JTcl distribution.
 
-critcl-3.1.15 is no longer needed for tsp4tcc uses tcc4tcl
+critcl-3.1.15 is no longer needed for tsp4tcc uses tcc4tcl (tcc 0.9.27)
+
+tcc4tcl (tcc 0.9.27) can be found here     https://github.com/MichaelMiR01/tcc4tcl/releases
+
+Precompiled binaries for tcc4tcl can be found here     https://github.com/MichaelMiR01/tccide/
 
 crtitcl can be found here, just in case    https://github.com/andreas-kupries/critcl/releases
 

From 3ca83f3f5d81ec548afd375c6c483f583327da60 Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Wed, 6 Jul 2022 19:06:09 +0200
Subject: [PATCH 11/39] catched console show (for linux tclsh)

---
 tsp-packagehelper.tcl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index 6998315..38b9692 100644
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -174,7 +174,7 @@ proc ::tsp::test_packageX {packagename {callcmd ""} {shell "./tclkit_866_3.upx.e
         puts "Creating new exec"
         set fd [open resrc.tcl w]
         puts "appending auto_path with [file dir $tsp::PACKAGE_DIR]"
-        puts $fd "console show"
+        puts $fd "catch {console show}"
         puts $fd "lappend auto_path [file dir $tsp::PACKAGE_DIR]"
         puts "Loading package... $packagename"
         puts $fd "package require $packagename"

From 8f4ef5f7332d44bf7050e82ce5298d598521e5ba Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Wed, 6 Jul 2022 19:35:20 +0200
Subject: [PATCH 12/39] fix undefined errorCode

---
 tsp-packagehelper.tcl | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index 38b9692..6fbf893 100644
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -542,6 +542,7 @@ proc ::tsp::compile_package {packagename {compiler tcc}} {
     #set cdirect [string map [list "$packagename.dll" $dllname] $cdirect]
     
     puts "Compiling external $cdirect"
+    set ::errorCode ""
     catch {
         eval exec $cdirect
     } err

From f58979fdfdfb2c5aeab6f88031d0a5ee21dac7ad Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Wed, 6 Jul 2022 19:58:25 +0200
Subject: [PATCH 13/39] Update README.md

---
 README.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index d7fc193..49ed52b 100644
--- a/README.md
+++ b/README.md
@@ -24,15 +24,15 @@ TSP is written entirely in Tcl, with support libraries written in C and Java.
 
 # Docs
 
-  1. [Introduction](https://github.com/tpoindex/tsp/blob/master/docs/introduction.md)
-  2. [Features](https://github.com/tpoindex/tsp/blob/master/docs/tsp-lang-features.md)
-  3. [Type System](https://github.com/tpoindex/tsp/blob/master/docs/type-system.md)
-  4. [Compiled Commands](https://github.com/tpoindex/tsp/blob/master/docs/compiled-commands.md)
-  5. [Runtime](https://github.com/tpoindex/tsp/blob/master/docs/runtime.md)
-  6. [Compiler Usage](https://github.com/tpoindex/tsp/blob/master/docs/compiler-usage.md)
-  7. [Future Improvements](https://github.com/tpoindex/tsp/blob/master/docs/future-improvements.md)
-  8. [Install](https://github.com/tpoindex/tsp/blob/master/docs/install.md)
-  9. [Misc.](https://github.com/tpoindex/tsp/blob/master/docs/misc.md)
+  1. [Introduction](./docs/introduction.md)
+  2. [Features](./docs/tsp-lang-features.md)
+  3. [Type System](./docs/type-system.md)
+  4. [Compiled Commands](./docs/compiled-commands.md)
+  5. [Runtime](./docs/runtime.md)
+  6. [Compiler Usage](./docs/compiler-usage.md)
+  7. [Future Improvements](./docs/future-improvements.md)
+  8. [Install](./docs/install.md)
+  9. [Misc.](./docs/misc.md)
 
 
 Wiki (Q & A, discussion, other): http://wiki.tcl.tk/Tcl%20Static%20Prime

From c70b817856e8372068a458b509b28c4b6ff8f6a3 Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Wed, 6 Jul 2022 20:00:24 +0200
Subject: [PATCH 14/39] Update tsp-lang-features.md

---
 docs/tsp-lang-features.md | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/docs/tsp-lang-features.md b/docs/tsp-lang-features.md
index 2a46429..8789488 100644
--- a/docs/tsp-lang-features.md
+++ b/docs/tsp-lang-features.md
@@ -50,14 +50,21 @@ a level of additional runtime interpretation.
     lappend foo {*}$s                ;# invalid: expansion syntax not allows
 ```
 
-## Namespace not supported for proc names
+## Namespace support limited for proc names 
 
-Currently, procedures can only be defined in the global namespace.
+Procedures can be defined in the global namespace or any valid namespace. 
+Still be careful with variables from namespaces, this is not tested very well
 
 ```
-    tsp::proc ::pkg::foo {} {        ;# invalid: namespace procname not allowed
+    tsp::proc ::pkg::foo {} {        ;# valid: 
         #tsp::procdef void
     }
+
+    tsp::proc ::pkg::foo {} {        ;# 
+        variable v                   ;#should work, but test before usage
+        #tsp::procdef void
+    }
+    
 ```
 
 ## Limitation on proc name and variable names

From 8f1a97b67249374a130a69335c804b5ba73250e9 Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Wed, 6 Jul 2022 20:30:28 +0200
Subject: [PATCH 15/39] Update tsp-lang-features.md

---
 docs/tsp-lang-features.md | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/docs/tsp-lang-features.md b/docs/tsp-lang-features.md
index 8789488..b6e526d 100644
--- a/docs/tsp-lang-features.md
+++ b/docs/tsp-lang-features.md
@@ -50,19 +50,24 @@ a level of additional runtime interpretation.
     lappend foo {*}$s                ;# invalid: expansion syntax not allows
 ```
 
-## Namespace support limited for proc names 
+## limited Namespace support for proc names and variables
 
-Procedures can be defined in the global namespace or any valid namespace. 
-Still be careful with variables from namespaces, this is not tested very well
+Procedures can be defined in the global namespace. Namespace qualifiers in the proc name are invalid 
 
 ```
-    tsp::proc ::pkg::foo {} {        ;# valid: 
+    tsp::proc ::pkg::foo {} {        ;# invalid: 
         #tsp::procdef void
     }
+```
+
+But you can define a project namespace with the variable tsp::PACKAGE_NAMESPACE; if defined, ALL procs will be rewritten to this namespace
 
-    tsp::proc ::pkg::foo {} {        ;# 
-        variable v                   ;#should work, but test before usage
+```
+set tsp::PACKAGE_NAMESPACE pkg
+    tsp::proc foo {} {        ;# will be rewritten pkg::foo
         #tsp::procdef void
+        #tsp::var v
+        variable v            ;# will be connected to $pkg::v
     }
     
 ```

From e237e9b2f56ee3e584f8cacfcea7cbb87b856d88 Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Wed, 6 Jul 2022 20:38:00 +0200
Subject: [PATCH 16/39] Update README.md

---
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/README.md b/README.md
index 49ed52b..495b454 100644
--- a/README.md
+++ b/README.md
@@ -21,6 +21,10 @@ invoked directly, bypassing the Tcl interpreter.
 
 TSP is written entirely in Tcl, with support libraries written in C and Java.
 
+Changes to original TSP
+* limited Namespace support for proc names and variables (see Features)
+* package support with ::tsp::init_package // ::tsp::finalize_package (documentation still todo)
+* some bugfixes I ran into 
 
 # Docs
 

From 304105cdf44ccb4834d7a9ddb5e17671390fa7dc Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Wed, 6 Jul 2022 22:06:16 +0200
Subject: [PATCH 17/39] Update tsp-lang-features.md

added description of package building support
---
 docs/tsp-lang-features.md | 65 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)

diff --git a/docs/tsp-lang-features.md b/docs/tsp-lang-features.md
index b6e526d..7f4603c 100644
--- a/docs/tsp-lang-features.md
+++ b/docs/tsp-lang-features.md
@@ -71,6 +71,71 @@ set tsp::PACKAGE_NAMESPACE pkg
     }
     
 ```
+## Package support
+Package support depends on the package tcc4tcl_helper to work, someday it will be integrated here, meanwhile find it here https://github.com/MichaelMiR01/tccide/tree/main/subpackages
+
+Package support (tsp_packagehelper.tcl) introduces two commands
+* ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0} {tclversion TCL_VERSION}}
+* ::tsp::finalize_package {{packagedir ""} {compiler none}}
+
+TSP will generate package code in the given packagedir (packagedir defaults to packagename).
+It writes out
+
+* packagename.c
+* packagename.tclprocs.tcl
+* packagename.puretcl.tcl
+* pkgIndex.tcl
+* packagename.dll
+
+compiler can be **intern/memory** or **export**. 
+
+   **intern** (eq memory) will compile to memory and immediatly install the compiled procs
+    
+   **export** will build a shared lib (.so//.dll) an write it into the package dir as **packagename.dll // packagename.so**
+
+* packagename.tclprocs.tcl    contains all TSP procs defined as tcl-only and will be sourced, if loading the dll fails
+* packagename.puretcl.tcl     TSP collects all proc definitions between init_package and finalize_package and spits them here. This will be sourced from pkgIndex, so not only tsp and tcc proc are loaded, but tcl procs can also be defined as helpers
+
+```
+#example
+package require tsp
+
+::tsp::init_package tnop 
+
+set handle $tsp::TCC_HANDLE
+$handle cproc cnop {Tcl_Interp* interp } char* {
+    // this is a pure c-function
+     return "cnop";
+}
+::tsp::proc tspnop {} {
+    #this is a transpiled function, its tcl code will go to tnop.tclprocs.tcl
+    #tsp::procdef void
+    puts "tspnop"
+}
+proc tclnop {} {
+    # this is a pure tcl function. its code will go to tnop.puretcl.tcl
+    puts "tclnop "
+}
+::tsp::printLog 
+::tsp::finalize_package tnop export
+```
+
+The exported package can now be loaded with package require packagename.
+
+Furthermore, TSP will try to spit out some compiler directives for tcc/gcc you can use as boilerplate to recompile the sourcecode with an optimizing compiler.
+
+Packages can be enriched with external libraries with the following directives:
+```
+proc ::tsp::add_tclinclude {fname}
+    # load tcls for additional sources, issues a source (fname) command into pkgIndex
+
+proc ::tsp::add_bininclude {fname} 
+    # load_dlls for dlls wich should be loaded into interp, issues a load (fname) command into pkgIndex
+
+proc ::tsp::add_dllinclude {fname}
+    # external dlls wich are dependencies and do not get loaded into interp but linked to your c-code (like jpeg.dll)
+    # tries to copy fname.dll into [pwd], so tcl can find it and dload
+```
 
 ## Limitation on proc name and variable names
 

From 474abdeaa650651c201041f03056bbad3d307168 Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Wed, 6 Jul 2022 22:07:32 +0200
Subject: [PATCH 18/39] Update README.md

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 495b454..3b89b98 100644
--- a/README.md
+++ b/README.md
@@ -22,8 +22,8 @@ invoked directly, bypassing the Tcl interpreter.
 TSP is written entirely in Tcl, with support libraries written in C and Java.
 
 Changes to original TSP
-* limited Namespace support for proc names and variables (see Features)
-* package support with ::tsp::init_package // ::tsp::finalize_package (documentation still todo)
+* limited Namespace support for proc names and variables (see  [Features](./docs/tsp-lang-features.md))
+* package support with ::tsp::init_package // ::tsp::finalize_package (see  [Features](./docs/tsp-lang-features.md))
 * some bugfixes I ran into 
 
 # Docs

From c4b0a3aeee6158e409116cfc2df7afa18ebf6cab Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Wed, 6 Jul 2022 22:11:37 +0200
Subject: [PATCH 19/39] init_package renemaes proc to collect procdef underway

---
 tsp-packagehelper.tcl | 43 ++++++++++++++++++++++++++++++-------------
 1 file changed, 30 insertions(+), 13 deletions(-)

diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index 6fbf893..a2299bd 100644
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -97,9 +97,24 @@ unsigned short __tcc_int_fpu_control = 0x137f | 0x0c00;
     set ::tsp::LOAD_DLLS "" 
     set ::tsp::EXTERNAL_DLLS "" 
     
+    if {[info command ::__proc] eq ""} {
+        rename ::proc ::__proc
+        ::__proc ::proc {procName procargs procbody} {
+            lappend ::tsp::TCL_PROCS  [list $procName $procargs $procbody]
+            if {[catch {uplevel 0 ::__proc [list $procName $procargs $procbody]} err]} {
+                rename ::proc ""
+                rename ::__proc ::proc
+                return -code error $err
+            }
+        }
+    }
 }
 
 proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
+    if {[info command ::__proc] eq "::__proc"} {
+        rename ::proc ""
+        rename ::__proc ::proc
+    }
     if {$::tsp::PACKAGE_NAME eq ""} {
          puts "Err: No package name given: use init_package packagename"
         set ::tsp::COMPILE_PACKAGE 0
@@ -133,18 +148,20 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
     ::tsp::write_pkgIndex $::tsp::PACKAGE_NAME
     
     # copy source to package... if already in place, rename
-    set t [clock format [clock seconds] -format "%Y-%m-%d_%H-%M-%S"]
-    set srcname "${::tsp::PACKAGE_NAME}_tsp_${t}.tcl"
-    set srcname [file join $tsp::PACKAGE_DIR $srcname]
-    set vdiff 1
-    catch {
-        set lastsrcname [file join $tsp::PACKAGE_DIR "${::tsp::PACKAGE_NAME}_tsp_*.tcl"]
-        set lastsrcname [lindex [lsort -decreasing [glob $lastsrcname]] 0]
-        set vdiff [version:filediff $::tsp::ACTSOURCE $lastsrcname]
-    }
-    if {$vdiff >0} {
-        puts "Copy src to $srcname"
-        file copy "$::tsp::ACTSOURCE" "$srcname"
+    if {[file exist $::tsp::ACTSOURCE]} {
+        set t [clock format [clock seconds] -format "%Y-%m-%d_%H-%M-%S"]
+        set srcname "${::tsp::PACKAGE_NAME}_tsp_${t}.tcl"
+        set srcname [file join $tsp::PACKAGE_DIR $srcname]
+        set vdiff 1
+        catch {
+            set lastsrcname [file join $tsp::PACKAGE_DIR "${::tsp::PACKAGE_NAME}_tsp_*.tcl"]
+            set lastsrcname [lindex [lsort -decreasing [glob $lastsrcname]] 0]
+            set vdiff [version:filediff $::tsp::ACTSOURCE $lastsrcname]
+        }
+        if {$vdiff >0} {
+            puts "Copy src to $srcname"
+            file copy "$::tsp::ACTSOURCE" "$srcname"
+        }
     }
     
     ::tsp::compile_package $::tsp::PACKAGE_NAME $compiler
@@ -558,7 +575,7 @@ proc ::tsp::compile_package {packagename {compiler tcc}} {
 
 proc ::tsp::splice_src {filename} {
     if {![file exists $filename]} {
-        puts "ERROR: $filename source not found"
+        #puts "ERROR: $filename source not found"
         return -1
     }
 

From 719502e10eff364fd7c099c19c8f150b4f5a0a2c Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Thu, 7 Jul 2022 07:46:32 +0200
Subject: [PATCH 20/39] added tcc4tcl_helper package as subdir for completeness
 required by tsp_packageelper

---
 tcc4tcl_helper/pkgIndex.tcl       |   1 +
 tcc4tcl_helper/tcc4tcl_helper.tcl | 552 ++++++++++++++++++++++++++++++
 2 files changed, 553 insertions(+)
 create mode 100644 tcc4tcl_helper/pkgIndex.tcl
 create mode 100644 tcc4tcl_helper/tcc4tcl_helper.tcl

diff --git a/tcc4tcl_helper/pkgIndex.tcl b/tcc4tcl_helper/pkgIndex.tcl
new file mode 100644
index 0000000..ea01d00
--- /dev/null
+++ b/tcc4tcl_helper/pkgIndex.tcl
@@ -0,0 +1 @@
+package ifneeded tcc4tcl_helper 0.1 [list source [file join $dir tcc4tcl_helper.tcl]]
diff --git a/tcc4tcl_helper/tcc4tcl_helper.tcl b/tcc4tcl_helper/tcc4tcl_helper.tcl
new file mode 100644
index 0000000..3609fd0
--- /dev/null
+++ b/tcc4tcl_helper/tcc4tcl_helper.tcl
@@ -0,0 +1,552 @@
+package provide tcc4tcl_helper 0.1
+
+namespace eval tccenv {
+    # some common envelope vars for our ide
+    variable localdir [pwd]
+    variable pathprefix [file dirname [file dirname [file dirname [info script]]]]
+    #puts "pwd [pwd] exe [info nameofexecutable] script [info script] prefix $pathprefix"
+    variable tccexecutabledir $localdir
+    variable tccexecutable  tcc.exe
+    variable tccmaindir     ${tccexecutabledir}
+    variable tccincludedir  ${tccexecutabledir}/include
+    variable tcclibdir      ${tccexecutabledir}/lib
+    
+    variable gccexecutabledir $localdir
+    variable gccexecutable  gcc.exe
+    variable gccmaindir     ${gccexecutabledir}
+    variable gccincludedir  ${gccexecutabledir}/include
+    variable gcclibdir      ${gccexecutabledir}/lib
+    
+    variable projectdir     ${tccexecutabledir}/project
+    variable projectincludedir  ${projectdir}/include
+    variable projectlibdir      ${projectdir}/lib
+    
+    variable includes_missing ""
+    
+    proc setprojectdir {pdir} {
+        variable projectdir
+        variable projectincludedir
+        variable projectlibdir
+        set projectdir $pdir
+        set projectincludedir  ${projectdir}/include
+        set projectlibdir      ${projectdir}/lib
+    }
+    proc settccexedir {pdir} {
+        variable tccexecutabledir
+        variable tccexecutable
+        variable tccmaindir
+        variable tccincludedir
+        variable tcclibdir
+        set searchpath {"" "tcc_0.9.27-bin"}
+        set tccexecutabledir [findfiledir $pdir $searchpath "tcc.exe"]
+        set tccmaindir  [file normalize ${tccexecutabledir}/]
+        set tccincludedir  ${tccexecutabledir}/include
+        set tcclibdir      ${tccexecutabledir}/lib
+    }
+    proc setgccexedir {pdir} {
+        variable gccexecutabledir
+        variable gccexecutable
+        variable gccmaindir
+        variable gccincludedir
+        variable gcclibdir
+        set searchpath {"" "gcc/bin" "tcc_0.9.27-bin/gcc/bin"}
+        set gccexecutabledir [findfiledir $pdir $searchpath "gcc.exe"]
+        set gccmaindir  [file normalize ${gccexecutabledir}/../../]
+        set gccincludedir  ${gccmaindir}/include
+        set gcclibdir      ${gccmaindir}/lib
+    }
+    
+    proc findfiledir {pdir searchpath filetofind} {
+        #
+        foreach p $searchpath {
+            set founddir [file join $pdir $p]
+            
+            if {![file exists [file join ${founddir} $filetofind]]} {
+                # try finding gcc            
+                puts "not found $filetofind in $founddir"
+            } else {
+                puts "!found $filetofind in $founddir"
+                return [file join $founddir ""]
+            }
+        }
+        return ""
+    }
+}
+
+proc ::tcc4tcl::getsubdirs {includepath} {
+    set retpath {}
+    #puts "Entering..."
+    foreach path $includepath {
+        #puts "Searching $path..."
+        if {![file isdir $path]} {
+            #try guessing in current subdirs
+            if {[file isdir [::tcc4tcl::shortenpath $path]]} {
+                set path [::tcc4tcl::shortenpath $path]; lappend retpath $path
+            } else {
+                if {[file isdir [file tail $path]]} {set path [file tail $path]; lappend retpath $path}
+            }
+            #puts "replacing path $path"
+        }
+        update
+        set subdirs ""
+        catch {
+            set subdirs [glob -nocomplain -directory $path -types d *]
+        }
+        foreach sub $subdirs {
+            #puts "got subdir ...$sub..."
+            set sub [file tail $sub]
+            lappend retpath [file join $path $sub]
+            append retpath " [::tcc4tcl::getsubdirs [file join $path $sub]]"
+        }
+    }
+    return $retpath
+}
+
+proc ::tcc4tcl::searchDir {dir inDir} {
+        #puts "Searching $dir in $inDir"
+        set subdirs ""
+        if {$dir==$inDir} {
+            return $inDir
+        }
+        catch {
+            set subdirs [glob -nocomplain -directory $inDir -types d *]
+        }
+        foreach sub $subdirs {
+            #puts "got subdir ...$sub..."
+            if {[file tail $sub]==$dir} {
+                return $sub
+            }
+        }
+        foreach sub $subdirs {
+             #puts "search subdir ...$sub..."
+             set d [::tcc4tcl::searchDir $dir $sub]
+             if {$d!=""} {
+                return $d
+            }
+        }
+        return ""
+}
+
+proc ::tcc4tcl::commonsubdir {d1 d2} {
+    # returns a list of three
+    # common dirpath
+    # rest of dir1
+    # rest of dir2
+    
+    set d1 [split [string map {\\ /} $d1] /]
+    set d2 [split [string map {\\ /} $d2] /]
+    set l1 [llength $d1]
+    set l2 [llength $d2]
+    if {$l1>$l2} {
+        # swap d1 d2
+        set d $d1
+        set d1 $d2
+        set d2 $d
+        set l1 $l2
+    }
+    set outlist {}
+    for {set i 0} {$i< $l1} {incr i} {
+        if {[lindex $d1 $i]==[lindex $d2 $i]} {
+            lappend outlist [lindex $d1 $i]
+        } else {
+            break;
+        }
+    }
+    set rest1 [lrange $d1 $i end]
+    set rest2 [lrange $d2 $i end]
+        
+    return [list [join $outlist /]/ [join $rest1 /] [join $rest2 /]]
+}
+
+proc ::tcc4tcl::makefileglob {includepath {filelist {}} {subdirs 1}} {
+    # create a filelist withh every file in every subpath as a lookup table
+    foreach path $includepath {
+        #puts "Searching $path"
+        set files [glob -tails -nocomplain -directory $path *.{h,c}]
+        foreach file $files {
+            lappend filelist $file $path
+        }
+        if {$subdirs>0} {
+            set subpaths [glob -nocomplain -directory $path -types d *]
+            set filelist [::tcc4tcl::makefileglob $subpaths $filelist $subdirs]
+        }
+    }
+    return $filelist
+}
+
+proc ::tcc4tcl::shortenpath {path {prefix ""}} {
+    #
+    set shortincludepath ""
+    if {$prefix==""} {
+        set prefix $::tccenv::pathprefix/
+    }
+    set prefix1 ${prefix}lib/
+    set prefix2 ${prefix}lib/tcc4tcl-0.30/
+    
+    #puts "Analysing $path"
+    set shortresult ""
+    set shortpath [string map [list $prefix ""] $path]
+    set shortpath1 [string map [list $prefix1 ""] $path] 
+    set shortpath2 [string map [list $prefix2 ""] $path] 
+    if {$shortpath2!=$path} { set shortresult $shortpath2; }
+    if {$shortpath1!=$path} { set shortresult $shortpath1; }
+    if {$shortpath!=$path} { set shortresult $shortpath; }
+    return shortresult
+}
+
+proc ::tcc4tcl::analyse_includes {handle {prefix ""}} {
+    variable includes_missing
+    set includes_missing ""
+    set code [$handle code]
+    #puts [string range $code 0 1024]
+    set includepath [$handle add_include_path]
+    append includepath " [::tcc4tcl::getsubdirs $includepath]"
+    set includepath [lsort -unique $includepath]
+    #puts $includepath
+    set filelist [::tcc4tcl::makefileglob $includepath]
+    
+    set usedpath [analyse_codeincludes "main source" $code $includepath ""]
+    puts "Possibly missing files: [expr [llength $includes_missing]/2]"
+    puts "list is in tcc4tcl::includes_missing"
+    set shortincludepath ""
+    if {$prefix==""} {
+        set prefix $::tccenv::pathprefix/
+    }
+    set prefix1 ${prefix}lib/
+    set prefix2 ${prefix}lib/tcc4tcl-0.30/
+    
+    foreach path $usedpath {
+        #puts "Analysing $path"
+        set shortpath [string map [list $prefix ""] $path]
+        set shortpath1 [string map [list $prefix1 ""] $path] 
+        set shortpath2 [string map [list $prefix2 ""] $path] 
+        if {$shortpath2!=$path} { lappend shortincludepath $shortpath2; continue}
+        if {$shortpath1!=$path} { lappend shortincludepath $shortpath1; continue}
+        if {$shortpath!=$path} { lappend shortincludepath $shortpath; continue}
+        lappend shortincludepath $shortpath;       
+    }
+    return $shortincludepath
+}
+
+proc ::tcc4tcl::analyse_codeincludes {fromfile code includepath mdone {usedpath ""}} {
+    # a simple (too simple) routine to find all include files and their paths recursivly
+    # unable to parse any kind of ifdef ifndef
+    # so will mostly try to find ANY file thats behind an #include directive
+    
+    variable done
+    variable includes_missing
+    #puts "Analysing ... $fromfile"
+    update
+    set done $mdone
+    set cinc 0
+    set includer "#include"
+    set rgincluder "#(\\s*)include"
+    set lines [split $code \n]
+    foreach line $lines {
+        #set pos [string first $includer [string tolower $line]]
+        set pos [regexp -nocase $rgincluder $line]
+        if {$pos>0} {
+            # found includer
+            set line [string range $line $pos end]
+            set rest [string range $line [string length $includer] end]
+            set start [string first "\"" $rest]
+            set end [string first "\"" $rest $start+1]
+            if {$start==-1} {
+                set start [string first "<" $rest]
+                set end [string first ">" $rest $start+1]
+            }
+            set filename [string trim [string range $rest $start+1 $end-1]]
+            if {$filename==""} {
+                continue
+            }
+            if {[lsearch $done $filename]==-1} {
+                while {[string range $filename 0 2] eq "../"} {
+                    set filename [string range $filename 3 end]
+                }
+                #puts "Searching ...$filename..."
+                #update
+                set undone 1
+                foreach path $includepath {
+                    if {[file exists [file join $path $filename]]} {
+                        set undone 0
+                        lappend done $filename
+                        lappend usedpath $path
+                        if {[file tail $filename]!=$filename} {
+                            #lappend done [file tail $filename]
+                            lappend usedpath [file join $path [file dir $filename]]
+                            #puts "Found $filename (adding [file join $path [file dir $filename]] and [file tail $filename])"
+                        }
+                        set fp [open [file join $path $filename]]
+                        set codenew [read $fp]
+                        close $fp
+                        #puts "found [file join $path $filename]"
+                        incr cinc
+                        set usedpath [analyse_codeincludes $filename $codenew $includepath $done $usedpath]
+                    } 
+                }
+                if {$undone>0} {
+                    #puts "Not found include  $fromfile -> $filename";
+                    lappend includes_missing $fromfile $filename
+                    lappend done $filename
+                }
+            }
+        }
+    }
+    return [lsort -unique $usedpath]
+}
+
+proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packageversion 1.0} {tclversion TCL_VERSION}} {
+    proc relTo {targetfile currentpath} {
+    # Get relative path to target file from current path
+    # First argument is a file name, second a directory name (not checked)
+        set cc [file split [file normalize $currentpath]]
+        set tt [file split [file normalize $targetfile]]
+        if {![string equal [lindex $cc 0] [lindex $tt 0]]} {
+            # not on *n*x then
+            return -code error "$targetfile not on same volume as $currentpath"
+        }
+        while {[string equal [lindex $cc 0] [lindex $tt 0]] && [llength $cc] > 0} {
+            # discard matching components from the front
+            set cc [lreplace $cc 0 0]
+            set tt [lreplace $tt 0 0]
+        }
+        set prefix {} 
+        if {[llength $cc] == 0} {
+            # just the file name, so targetfile is lower down (or in same place)
+            set prefix .
+        }
+        # step up the tree
+        for {set i 0} {$i < [llength $cc]} {incr i} {
+            append prefix { ..}
+        }
+        # stick it all together
+        file join {*}$prefix {*}$tt
+    }
+    proc eol {} {
+        switch -- $::tcl_platform(platform) {
+            windows {return \r\n}
+            unix {return \n}
+            macintosh {return \r}
+            default {\n}
+        }
+    }
+
+        set DLEXPORTMAKRO "
+/***************** DLL EXPORT MAKRO FOR TCC AND GCC ************/
+#if (defined(_WIN32) && (defined(_MSC_VER)|| defined(__TINYC__)  || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x0550)) || defined(__LCC__) || defined(__WATCOMC__) || (defined(__GNUC__) && defined(__declspec))))
+#undef DLLIMPORT
+#undef DLLEXPORT
+#   define DLLIMPORT __declspec(dllimport)
+#   define DLLEXPORT __declspec(dllexport)
+#else
+#   define DLLIMPORT __attribute__(dllimport)
+#   if defined(__GNUC__) && __GNUC__ > 3
+#       define DLLEXPORT __attribute__ ((visibility(\"default\")))
+#   else
+#       define DLLEXPORT
+#   endif
+#endif
+/***************************************************************/
+"        
+    upvar #0 $handle state
+    set oldtype "package"
+    if {$state(type)!="package"} {
+        set oldtype $state(type)
+        set state(package) [list $packagename $packageversion $tclversion]
+        set state(type) "package"
+    }
+    
+    #modify code with dlexportmakro
+    set oldcode $state(code)
+    set newcode $DLEXPORTMAKRO
+    append newcode $oldcode
+    set state(code) $newcode
+    
+    puts "Writing Package $packagename --> $filepath"
+    set mycode [$handle code]
+    # beautify code
+    set mycode [::tcc4tcl::reformat [string map [list [eol] \n] $mycode] 4]
+    set $state(type) $oldtype
+    puts [$handle add_include_path] 
+    
+    set pathway [::tcc4tcl::analyse_includes $handle]
+    #puts "Paths: $pathway"
+    set includestcc "-Iinclude -Iinclude/stdinc -Iinclude/generic -Iinclude/generic/win -Iinclude/xlib -Iwin32 -Iwin32/winapi "
+    set includesgcc "-Iinclude -Iinclude/generic -Iinclude/generic/win -Iinclude/xlib"
+    set includeslin64 "-Iinclude -Iinclude/generic -Iinclude/generic/unix -Iinclude/xlib"
+    set librariestcc "-ltclstub86elf -ltkstub86elf"
+    set librariesgcc "-Llib -ltclstub86 -ltkstub86"
+    set librarieslin64 "-Llib -ltclstub86_64 -ltkstub86_64"
+    
+    foreach incpath $pathway {
+        #lappend includestcc "-I$incpath"
+        if {[string first include/ [string tolower $incpath]]<0} {
+            if {[string first win32 [string tolower $incpath]]<0} {
+                lappend includestcc "-I$incpath"
+                lappend includesgcc "-I$incpath"
+                lappend includeslin64 "-I$incpath"
+            }
+        }
+    }
+    lappend librariestcc "-Llib"
+    lappend librariesgcc "-Llib"
+    lappend librarieslin64 "-Llib"
+    set libps [$handle add_library_path]
+    set libs [$handle add_library]
+    foreach inclib $libs {
+        lappend librariestcc "-l$inclib"
+        set found 0
+        foreach incpath $libps {
+            if {[file exists [file join $incpath ${inclib}.dll]]} {
+                lappend librariesgcc [file join $incpath $inclib.dll]
+                set found 1
+                break
+            }
+            if {[file exists [file join $incpath ${inclib}.so]]} {
+                lappend librarieslin64 [file join $incpath $inclib.so]
+                set found 1
+                break
+            }
+        }
+        foreach incpath $libps {
+            if {[file exists [file join $incpath lib${inclib}.a]]} {
+                lappend librariesgcc [file join $incpath $inclib.dll]
+                set found 1
+                break
+            }
+            if {[file exists [file join $incpath lib${inclib}.so]]} {
+                lappend librarieslin64 [file join $incpath $inclib.so]
+                set found 1
+                break
+            }
+        }
+        if {$found ==0} {
+            puts "Warning: Not found library $inclib"
+            lappend librariesgcc $inclib
+        }
+            
+    }
+    foreach incpath $libps {
+        lappend librariestcc "-L$incpath"
+        lappend librariesgcc "-L$incpath"
+    }
+    
+    if {[string first $::tccenv::tccexecutabledir $::tccenv::localdir]<0} {
+        set absfilepath [file normalize $filepath]
+    } else {
+        set absfilepath $filepath
+    }
+    
+    set relfilepath [relTo $filepath $::tccenv::tccmaindir]
+    
+    set tccpath [file join $::tccenv::tccexecutabledir $::tccenv::tccexecutable]
+    set gccpath [file join $::tccenv::gccexecutabledir $::tccenv::gccexecutable]
+    set gccoptions "-O2 -fwhole-program"
+    set gccoptions "-O2 -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,-s"
+    set gccoptions "-O2"
+    set tcc_compile "$tccpath -shared -DUSE_TCL_STUBS $includestcc [file join $absfilepath "$packagename.c"] -o[file join $absfilepath "$packagename.dll"] $librariestcc"
+    set gcc_compile "$gccpath -shared -s -m32 -D_WIN32 -DUSE_TCL_STUBS -static-libgcc $includesgcc [file join $absfilepath "$packagename.c"] $librariesgcc  -o[file join $absfilepath "$packagename.dll"] $gccoptions"
+    set cross_compile "i686-w64-mingw32-gcc -shared -s -m32 -D_WIN32 -DUSE_TCL_STUBS -static-libgcc $includesgcc [file join $relfilepath "$packagename.c"] $librariesgcc  -o[file join $relfilepath "$packagename.dll"] $gccoptions"
+    set lin64_compile "gcc -shared -s -fPIC -D_GNU_SOURCE -DUSE_TCL_STUBS $includeslin64 [file join $relfilepath "$packagename.c"] $librarieslin64  -o[file join $relfilepath "$packagename.so"] $gccoptions"
+
+    puts "\n$tcc_compile\n"
+    puts "\n$gcc_compile\n"
+    puts "\n$cross_compile\n"
+    puts "\n$lin64_compile\n"
+    
+    set filename [file join $filepath "$packagename.c"]
+
+    set fp [open $filename w]
+    puts $fp "/***************** Automatically Created with TCC4TCL Helper and maybe TSP **********************************/"
+    puts $fp "/* Compiler directives are raw estimates, please adapt to given pathstructure */\n"
+    puts $fp "/* $tcc_compile  */\n"
+    puts $fp "/* $gcc_compile */\n"
+    puts $fp "/* $cross_compile  */\n"
+    puts $fp "/* $lin64_compile  */\n"
+    puts $fp "/***************** Automatically Created with TCC4TCL Helper and maybe TSP **********************************/"
+    puts $fp $mycode
+    close $fp
+    return [list $tcc_compile $gcc_compile $cross_compile $lin64_compile]
+}
+
+proc ::tcc4tcl::reformat {tclcode {pad 4}} {
+    proc count {string char} {
+        set count 0
+        while {[set idx [string first $char $string]]>=0} {
+            set backslashes 0
+            set nidx $idx
+            while {[string equal [string index $string [incr nidx -1]] \\]} {
+                incr backslashes
+            }
+            if {$backslashes % 2 == 0} {
+                incr count
+            }
+            set string [string range $string [incr idx] end]
+        }
+        return $count
+    }
+
+    set lines [split $tclcode \n]
+    set out ""
+    set continued no
+    set oddquotes 0
+    set line [lindex $lines 0]
+    set indent [expr {([string length $line]-[string length [string trimleft $line \ \t]])/$pad}]
+    set pad [string repeat " " $pad]
+    
+    foreach orig $lines {
+        set newline [string trim $orig \ \t]
+        if {$newline eq ""} {
+            if {$continued} {
+                set line ""
+                set continued no
+                incr indent -2
+            } else {
+                continue
+            }
+        } else {
+            set line $orig
+        }
+        if {[string index $line end] eq "\\"} {
+            if {(!$continued)&&(!([string index $line end-1] eq "\*"))} {
+                incr indent 2
+                set continued yes
+            }
+        } elseif {$continued} {
+            incr indent -2
+            set continued no
+        }
+
+        if {(0)&&(![regexp {^[ \t]*\#} $line])&&(![regexp {^[ \t]*\\\*} $line]) } {
+            # oddquotes contains : 0 when quotes are balanced
+            # and 1 when they are not
+            set oddquotes [expr {([count $line \"] + $oddquotes) % 2}]
+            if {! $oddquotes} {
+                set  nbbraces  [count $line \{]
+                incr nbbraces -[count $line \}]
+                set brace   [string equal [string index $newline end] \{]
+                set unbrace [string equal [string index $newline 0] \}]
+                if {$nbbraces>0 || $brace} {
+                    incr indent $nbbraces ;# [GWM] 010409 multiple open braces
+                }
+                if {$nbbraces<0 || $unbrace} {
+                    incr indent $nbbraces ;# [GWM] 010409 multiple close braces
+                    if {$indent<0} {
+                        error "unbalanced braces"
+                    }
+                    ## was: set line [string range $line [string length $pad] end]
+                    # 010409 remove multiple brace indentations. Including case
+                    # where "\} else \{" needs to unindent this line but not later lines.
+                    set np [expr {$unbrace? [string length $pad]:-$nbbraces*[string length $pad]}]
+                    set line [string range $line $np end]
+                }
+            } else {
+                # unbalanced quotes, preserve original indentation
+                set line $orig
+            }
+        }
+        append out $line\n
+    }
+    return $out
+}
+

From 4b260a0ca2d6692cd40ad08b3ccc932a688df121 Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Thu, 7 Jul 2022 08:02:01 +0200
Subject: [PATCH 21/39] Update compiler-usage.md

---
 docs/compiler-usage.md | 32 +++++++++++++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/docs/compiler-usage.md b/docs/compiler-usage.md
index ea40115..a5e988a 100644
--- a/docs/compiler-usage.md
+++ b/docs/compiler-usage.md
@@ -100,7 +100,37 @@ vwait, etc.)
             include tracing on variables and the return values.  This can be useful to 
             isolate variable that may cause conversion errors.  See the Tracing section below.
 
-
+### `#tsp::inlinec`
+`#tsp::inlinec` defines a pure c line, that will be put into the source code directly without changes, so it is possible to e.g. call other c-procs directly (given you know the calling conventions) etc.
+
+### `#tsp::altTCL`
+`#tsp::altTCL` is put into the generated tcl code (use if compilation/loading fails), so you can give alternate TCL versions of inlineC parts
+    
+```
+
+#example
+package require tsp
+
+set handle $::tsp::TCC_HANDLE
+$handle cproc t1 {int i} double {;#define a simple c procedure here -- it will be compile as c_t1 later
+    return i*0.5;
+}
+tsp::proc test {} {
+    #tsp::procdef double
+    #tsp::int i
+    #tsp::double l k
+    set k 1.0
+    for {set i 0} {$i<100000} {incr i} {;# $i will be decorated as __i in TSP, $l as __l and so on
+        #tsp::inlinec __l = c_t1(__i);
+        #tsp::altTCL set l [t1 $i]
+        #tsp::inlinec __k = __k+sqrt(__l*__l*0.33);
+        #tsp::altTCL set k [expr {$k+sqrt($l*$l*0.33)}]
+    }
+    return $k
+}
+
+
+```
 
 ## Trace compile type
 

From d3c90c03d86734d104921bff51f29495163eb2ed Mon Sep 17 00:00:00 2001
From: Michael Richter <107300591+MichaelMiR01@users.noreply.github.com>
Date: Thu, 7 Jul 2022 08:03:57 +0200
Subject: [PATCH 22/39] Update README.md

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 3b89b98..4671d97 100644
--- a/README.md
+++ b/README.md
@@ -24,6 +24,7 @@ TSP is written entirely in Tcl, with support libraries written in C and Java.
 Changes to original TSP
 * limited Namespace support for proc names and variables (see  [Features](./docs/tsp-lang-features.md))
 * package support with ::tsp::init_package // ::tsp::finalize_package (see  [Features](./docs/tsp-lang-features.md))
+* #tsp::inlinec and #tsp::altTCL directives to include native c-code and alternative tcl-code (see [Compiler Usage](./docs/compiler-usage.md))
 * some bugfixes I ran into 
 
 # Docs

From 77d35880f84a0717a23a046c15291f4211ab4c97 Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Thu, 7 Jul 2022 08:07:46 +0200
Subject: [PATCH 23/39] changed docs

---
 docs/compiler-usage.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/docs/compiler-usage.md b/docs/compiler-usage.md
index a5e988a..c4f17ac 100644
--- a/docs/compiler-usage.md
+++ b/docs/compiler-usage.md
@@ -42,12 +42,14 @@ proc can also be specified with a single underscore **('_')**.
 a convenience for `tsp::log _`
 
 
-### `tsp::printLog` *?outfd? ?proc?*
+### `tsp::printLog` *?outfd? ?proc? ?breakeval?*
 
 `tsp::printLog` prints the compiler log.  Optional outfd specifies a writable file handle, stderr
 is the default.  Optional proc is specified, only that log is returned.  The most recent compiled
 proc can also be specified with a single underscore **('_')**.
 
+**breakeval** defaults to 1, so that TSP returns with an error, if there are any errors in transpilation.
+
 
 ## Annotations
 

From ec96fd1be1461db8691d50e05766324a3a3866aa Mon Sep 17 00:00:00 2001
From: tcllab <97413632+tcllab@users.noreply.github.com>
Date: Thu, 21 Jul 2022 16:51:45 -0500
Subject: [PATCH 24/39] add latest code from tsp-package_220717.tar.gz

---
 docs/compiled-commands.md                     |    0
 docs/compiler-usage.md                        |   36 +-
 docs/future-improvements.md                   |    0
 docs/install.md                               |    0
 docs/introduction.md                          |    0
 docs/misc.md                                  |    0
 docs/outline.md                               |    0
 docs/runtime.md                               |    0
 docs/tsp-lang-features.md                     |   83 +-
 docs/tutorial.md                              |    0
 docs/type-system.md                           |    0
 native/clang/TSP_cmd.c                        |    0
 native/clang/TSP_func.c                       |    0
 native/clang/TSP_util.c                       |    0
 native/clang/backup_n.tcl                     |   23 +
 native/clang/cvs/TSP_cmd.2015-07-28_21-19.c   | 1679 ++++++++++++++++
 native/clang/cvs/TSP_cmd.2022-04-28_18-24.c   | 1683 ++++++++++++++++
 native/clang/cvs/TSP_cmd.2022-07-01_14-56.c   | 1683 ++++++++++++++++
 native/clang/cvs/TSP_cmd.2022-07-01_16-28.c   | 1689 +++++++++++++++++
 native/clang/cvs/TSP_func.2022-04-23_07-49.c  |  426 +++++
 native/clang/cvs/TSP_func.2022-04-25_14-34.c  |  461 +++++
 native/clang/cvs/TSP_func.2022-05-13_12-11.c  |  462 +++++
 native/clang/cvs/TSP_func.2022-05-16_19-15.c  |  464 +++++
 native/clang/cvs/TSP_func.2022-07-01_14-53.c  |  464 +++++
 native/clang/cvs/TSP_func.2022-07-01_16-24.c  |  464 +++++
 native/clang/cvs/TSP_util.2015-07-28_21-19.c  |  304 +++
 native/clang/cvs/TSP_util.2022-04-24_23-21.c  |  304 +++
 native/clang/cvs/TSP_util.2022-05-13_12-25.c  |  313 +++
 native/clang/cvs/TSP_util.2022-07-01_14-55.c  |  313 +++
 native/clang/cvs/TSP_util.2022-07-01_16-24.c  |  313 +++
 .../clang/cvs/backup_n.2021-07-30_16-32.tcl   |   23 +
 parser/pkgIndex.tcl                           |    0
 parser/tclParser.c                            |    0
 parser/tclparser.dll                          |  Bin
 parser/tclparser.so                           |  Bin
 pkgIndex.tcl                                  |    0
 tsp-clang.tcl                                 |    0
 tsp-compile.tcl                               |    0
 tsp-expr.tcl                                  |    0
 tsp-generate-control.tcl                      |    0
 tsp-generate-list.tcl                         |    0
 tsp-generate-math.tcl                         |    0
 tsp-generate-set.tcl                          |    0
 tsp-generate-string.tcl                       |    0
 tsp-generate-var.tcl                          |    0
 tsp-generate.tcl                              |    0
 tsp-logging.tcl                               |    0
 tsp-packagehelper.tcl                         |    0
 tsp-parse.tcl                                 |    0
 tsp-trace.tcl                                 |    0
 tsp-types.tcl                                 |    0
 tsp.tcl                                       |    0
 52 files changed, 11073 insertions(+), 114 deletions(-)
 mode change 100644 => 100755 docs/compiled-commands.md
 mode change 100644 => 100755 docs/compiler-usage.md
 mode change 100644 => 100755 docs/future-improvements.md
 mode change 100644 => 100755 docs/install.md
 mode change 100644 => 100755 docs/introduction.md
 mode change 100644 => 100755 docs/misc.md
 mode change 100644 => 100755 docs/outline.md
 mode change 100644 => 100755 docs/runtime.md
 mode change 100644 => 100755 docs/tsp-lang-features.md
 mode change 100644 => 100755 docs/tutorial.md
 mode change 100644 => 100755 docs/type-system.md
 mode change 100644 => 100755 native/clang/TSP_cmd.c
 mode change 100644 => 100755 native/clang/TSP_func.c
 mode change 100644 => 100755 native/clang/TSP_util.c
 create mode 100755 native/clang/backup_n.tcl
 create mode 100755 native/clang/cvs/TSP_cmd.2015-07-28_21-19.c
 create mode 100755 native/clang/cvs/TSP_cmd.2022-04-28_18-24.c
 create mode 100755 native/clang/cvs/TSP_cmd.2022-07-01_14-56.c
 create mode 100755 native/clang/cvs/TSP_cmd.2022-07-01_16-28.c
 create mode 100755 native/clang/cvs/TSP_func.2022-04-23_07-49.c
 create mode 100755 native/clang/cvs/TSP_func.2022-04-25_14-34.c
 create mode 100755 native/clang/cvs/TSP_func.2022-05-13_12-11.c
 create mode 100755 native/clang/cvs/TSP_func.2022-05-16_19-15.c
 create mode 100755 native/clang/cvs/TSP_func.2022-07-01_14-53.c
 create mode 100755 native/clang/cvs/TSP_func.2022-07-01_16-24.c
 create mode 100755 native/clang/cvs/TSP_util.2015-07-28_21-19.c
 create mode 100755 native/clang/cvs/TSP_util.2022-04-24_23-21.c
 create mode 100755 native/clang/cvs/TSP_util.2022-05-13_12-25.c
 create mode 100755 native/clang/cvs/TSP_util.2022-07-01_14-55.c
 create mode 100755 native/clang/cvs/TSP_util.2022-07-01_16-24.c
 create mode 100755 native/clang/cvs/backup_n.2021-07-30_16-32.tcl
 mode change 100644 => 100755 parser/pkgIndex.tcl
 mode change 100644 => 100755 parser/tclParser.c
 mode change 100644 => 100755 parser/tclparser.dll
 mode change 100644 => 100755 parser/tclparser.so
 mode change 100644 => 100755 pkgIndex.tcl
 mode change 100644 => 100755 tsp-clang.tcl
 mode change 100644 => 100755 tsp-compile.tcl
 mode change 100644 => 100755 tsp-expr.tcl
 mode change 100644 => 100755 tsp-generate-control.tcl
 mode change 100644 => 100755 tsp-generate-list.tcl
 mode change 100644 => 100755 tsp-generate-math.tcl
 mode change 100644 => 100755 tsp-generate-set.tcl
 mode change 100644 => 100755 tsp-generate-string.tcl
 mode change 100644 => 100755 tsp-generate-var.tcl
 mode change 100644 => 100755 tsp-generate.tcl
 mode change 100644 => 100755 tsp-logging.tcl
 mode change 100644 => 100755 tsp-packagehelper.tcl
 mode change 100644 => 100755 tsp-parse.tcl
 mode change 100644 => 100755 tsp-trace.tcl
 mode change 100644 => 100755 tsp-types.tcl
 mode change 100644 => 100755 tsp.tcl

diff --git a/docs/compiled-commands.md b/docs/compiled-commands.md
old mode 100644
new mode 100755
diff --git a/docs/compiler-usage.md b/docs/compiler-usage.md
old mode 100644
new mode 100755
index c4f17ac..ea40115
--- a/docs/compiler-usage.md
+++ b/docs/compiler-usage.md
@@ -42,14 +42,12 @@ proc can also be specified with a single underscore **('_')**.
 a convenience for `tsp::log _`
 
 
-### `tsp::printLog` *?outfd? ?proc? ?breakeval?*
+### `tsp::printLog` *?outfd? ?proc?*
 
 `tsp::printLog` prints the compiler log.  Optional outfd specifies a writable file handle, stderr
 is the default.  Optional proc is specified, only that log is returned.  The most recent compiled
 proc can also be specified with a single underscore **('_')**.
 
-**breakeval** defaults to 1, so that TSP returns with an error, if there are any errors in transpilation.
-
 
 ## Annotations
 
@@ -102,37 +100,7 @@ vwait, etc.)
             include tracing on variables and the return values.  This can be useful to 
             isolate variable that may cause conversion errors.  See the Tracing section below.
 
-### `#tsp::inlinec`
-`#tsp::inlinec` defines a pure c line, that will be put into the source code directly without changes, so it is possible to e.g. call other c-procs directly (given you know the calling conventions) etc.
-
-### `#tsp::altTCL`
-`#tsp::altTCL` is put into the generated tcl code (use if compilation/loading fails), so you can give alternate TCL versions of inlineC parts
-    
-```
-
-#example
-package require tsp
-
-set handle $::tsp::TCC_HANDLE
-$handle cproc t1 {int i} double {;#define a simple c procedure here -- it will be compile as c_t1 later
-    return i*0.5;
-}
-tsp::proc test {} {
-    #tsp::procdef double
-    #tsp::int i
-    #tsp::double l k
-    set k 1.0
-    for {set i 0} {$i<100000} {incr i} {;# $i will be decorated as __i in TSP, $l as __l and so on
-        #tsp::inlinec __l = c_t1(__i);
-        #tsp::altTCL set l [t1 $i]
-        #tsp::inlinec __k = __k+sqrt(__l*__l*0.33);
-        #tsp::altTCL set k [expr {$k+sqrt($l*$l*0.33)}]
-    }
-    return $k
-}
-
-
-```
+
 
 ## Trace compile type
 
diff --git a/docs/future-improvements.md b/docs/future-improvements.md
old mode 100644
new mode 100755
diff --git a/docs/install.md b/docs/install.md
old mode 100644
new mode 100755
diff --git a/docs/introduction.md b/docs/introduction.md
old mode 100644
new mode 100755
diff --git a/docs/misc.md b/docs/misc.md
old mode 100644
new mode 100755
diff --git a/docs/outline.md b/docs/outline.md
old mode 100644
new mode 100755
diff --git a/docs/runtime.md b/docs/runtime.md
old mode 100644
new mode 100755
diff --git a/docs/tsp-lang-features.md b/docs/tsp-lang-features.md
old mode 100644
new mode 100755
index 7f4603c..2a46429
--- a/docs/tsp-lang-features.md
+++ b/docs/tsp-lang-features.md
@@ -50,93 +50,16 @@ a level of additional runtime interpretation.
     lappend foo {*}$s                ;# invalid: expansion syntax not allows
 ```
 
-## limited Namespace support for proc names and variables
+## Namespace not supported for proc names
 
-Procedures can be defined in the global namespace. Namespace qualifiers in the proc name are invalid 
+Currently, procedures can only be defined in the global namespace.
 
 ```
-    tsp::proc ::pkg::foo {} {        ;# invalid: 
+    tsp::proc ::pkg::foo {} {        ;# invalid: namespace procname not allowed
         #tsp::procdef void
     }
 ```
 
-But you can define a project namespace with the variable tsp::PACKAGE_NAMESPACE; if defined, ALL procs will be rewritten to this namespace
-
-```
-set tsp::PACKAGE_NAMESPACE pkg
-    tsp::proc foo {} {        ;# will be rewritten pkg::foo
-        #tsp::procdef void
-        #tsp::var v
-        variable v            ;# will be connected to $pkg::v
-    }
-    
-```
-## Package support
-Package support depends on the package tcc4tcl_helper to work, someday it will be integrated here, meanwhile find it here https://github.com/MichaelMiR01/tccide/tree/main/subpackages
-
-Package support (tsp_packagehelper.tcl) introduces two commands
-* ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0} {tclversion TCL_VERSION}}
-* ::tsp::finalize_package {{packagedir ""} {compiler none}}
-
-TSP will generate package code in the given packagedir (packagedir defaults to packagename).
-It writes out
-
-* packagename.c
-* packagename.tclprocs.tcl
-* packagename.puretcl.tcl
-* pkgIndex.tcl
-* packagename.dll
-
-compiler can be **intern/memory** or **export**. 
-
-   **intern** (eq memory) will compile to memory and immediatly install the compiled procs
-    
-   **export** will build a shared lib (.so//.dll) an write it into the package dir as **packagename.dll // packagename.so**
-
-* packagename.tclprocs.tcl    contains all TSP procs defined as tcl-only and will be sourced, if loading the dll fails
-* packagename.puretcl.tcl     TSP collects all proc definitions between init_package and finalize_package and spits them here. This will be sourced from pkgIndex, so not only tsp and tcc proc are loaded, but tcl procs can also be defined as helpers
-
-```
-#example
-package require tsp
-
-::tsp::init_package tnop 
-
-set handle $tsp::TCC_HANDLE
-$handle cproc cnop {Tcl_Interp* interp } char* {
-    // this is a pure c-function
-     return "cnop";
-}
-::tsp::proc tspnop {} {
-    #this is a transpiled function, its tcl code will go to tnop.tclprocs.tcl
-    #tsp::procdef void
-    puts "tspnop"
-}
-proc tclnop {} {
-    # this is a pure tcl function. its code will go to tnop.puretcl.tcl
-    puts "tclnop "
-}
-::tsp::printLog 
-::tsp::finalize_package tnop export
-```
-
-The exported package can now be loaded with package require packagename.
-
-Furthermore, TSP will try to spit out some compiler directives for tcc/gcc you can use as boilerplate to recompile the sourcecode with an optimizing compiler.
-
-Packages can be enriched with external libraries with the following directives:
-```
-proc ::tsp::add_tclinclude {fname}
-    # load tcls for additional sources, issues a source (fname) command into pkgIndex
-
-proc ::tsp::add_bininclude {fname} 
-    # load_dlls for dlls wich should be loaded into interp, issues a load (fname) command into pkgIndex
-
-proc ::tsp::add_dllinclude {fname}
-    # external dlls wich are dependencies and do not get loaded into interp but linked to your c-code (like jpeg.dll)
-    # tries to copy fname.dll into [pwd], so tcl can find it and dload
-```
-
 ## Limitation on proc name and variable names
 
 Procedure names and variable names inside of procedures must follow strict naming conventions.
diff --git a/docs/tutorial.md b/docs/tutorial.md
old mode 100644
new mode 100755
diff --git a/docs/type-system.md b/docs/type-system.md
old mode 100644
new mode 100755
diff --git a/native/clang/TSP_cmd.c b/native/clang/TSP_cmd.c
old mode 100644
new mode 100755
diff --git a/native/clang/TSP_func.c b/native/clang/TSP_func.c
old mode 100644
new mode 100755
diff --git a/native/clang/TSP_util.c b/native/clang/TSP_util.c
old mode 100644
new mode 100755
diff --git a/native/clang/backup_n.tcl b/native/clang/backup_n.tcl
new file mode 100755
index 0000000..82fed8a
--- /dev/null
+++ b/native/clang/backup_n.tcl
@@ -0,0 +1,23 @@
+#!/usr/bin/tclsh
+## exec tclkit
+## Backup
+
+set t [clock format [clock seconds] -format "%Y-%m-%d_%H-%M"]
+catch {console show}
+file mkdir "./cvs"
+foreach f0 [glob -nocomplain [file join "./" *]] {
+    if {[file isfile $f0]} {
+        set f [file tail $f0]
+        set n [file rootname $f]
+        set x [file extension $f]
+        set t0 [file mtime $f0]
+        set ts0 [clock format $t0 -format "%Y-%m-%d_%H-%M"]
+        #if {$f!=[file tail $::argv0]} {
+            set f1 "./cvs/$n.$ts0$x"
+            if {![file exists $f1]} { 
+                puts "copy $f0 $f1"
+                file copy $f0 $f1
+            }
+        #}
+    }
+}
diff --git a/native/clang/cvs/TSP_cmd.2015-07-28_21-19.c b/native/clang/cvs/TSP_cmd.2015-07-28_21-19.c
new file mode 100755
index 0000000..8331765
--- /dev/null
+++ b/native/clang/cvs/TSP_cmd.2015-07-28_21-19.c
@@ -0,0 +1,1679 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+/* return a pointer to a user direct command function, assumes
+   that user command puts the inner direct command into clientdata */
+
+void*
+TSP_User_getCmd(Tcl_Interp* interp, char* cmd) {
+    Tcl_CmdInfo cmdInfo;
+    int rc;
+    Tcl_ObjCmdProc* objCmd;
+    void* userCmd = NULL;
+    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
+    if (rc == 0) {
+        Tcl_Panic("TSP_User_getCmd: can't get command proc for %s", cmd);
+    } else {
+        objCmd = cmdInfo.objProc;
+        rc = objCmd(&userCmd, interp, 0, NULL);
+    }
+     return userCmd;
+}
+
+/* return a pointer to a Tcl command info */
+/* cmd info data is not preserved across multiple calls */
+
+Tcl_CmdInfo*
+TSP_Cmd_getCmdInfo(Tcl_Interp* interp, char* cmd) {
+    static Tcl_CmdInfo cmdInfo;
+    int rc;
+    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
+    if (rc == 0) {
+        Tcl_Panic("TSP_Cmd_getCmdInfo: can't get command proc for %s", cmd);
+    }
+     return &cmdInfo;
+}
+
+
+/* builtins command - a function that calls the builtin and fills in command obj name */
+
+int
+TSP_Cmd_builtin_after (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::after");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("after", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_append (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::append");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("append", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_apply (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::apply");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("apply", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_array (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::array");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("array", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_binary (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::binary");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("binary", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_break (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::break");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("break", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_case (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::case");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("case", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_catch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::catch");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("catch", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_cd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::cd");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("cd", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_chan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::chan");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("chan", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_clock (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::clock");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("clock", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_close (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::close");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("close", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_concat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::concat");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("concat", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_continue (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::continue");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("continue", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_dict (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::dict");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("dict", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_encoding (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::encoding");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("encoding", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_eof (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eof");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("eof", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_error (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::error");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("error", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_eval (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eval");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("eval", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_exec (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exec");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("exec", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_exit (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exit");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("exit", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_expr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::expr");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("expr", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_fblocked (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fblocked");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fblocked", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_fconfigure (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fconfigure");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fconfigure", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_fcopy (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fcopy");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fcopy", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_file (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::file");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("file", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_fileevent (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fileevent");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fileevent", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_flush (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::flush");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("flush", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_for (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::for");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("for", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_foreach (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::foreach");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("foreach", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_format (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::format");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("format", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_gets (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::gets");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("gets", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_glob (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::glob");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("glob", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_global (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::global");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("global", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_if (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::if");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("if", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_incr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::incr");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("incr", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_info (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::info");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("info", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_interp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::interp");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("interp", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_join (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::join");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("join", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lappend (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lappend");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lappend", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lassign (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lassign");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lassign", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lindex (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lindex");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lindex", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_linsert (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::linsert");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("linsert", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_list (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::list");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("list", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_llength (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::llength");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("llength", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lmap (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lmap");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lmap", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_load (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::load");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("load", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lrange (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrange");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lrange", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lrepeat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrepeat");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lrepeat", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lreplace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreplace");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lreplace", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lreverse (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreverse");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lreverse", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lsearch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsearch");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lsearch", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lset");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lset", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lsort (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsort");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lsort", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_namespace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::namespace");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("namespace", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_open (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::open");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("open", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_package (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::package");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("package", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_pid (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pid");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("pid", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_proc (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::proc");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("proc", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_puts (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::puts");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("puts", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_pwd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pwd");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("pwd", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_read (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::read");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("read", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_regexp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regexp");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("regexp", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_regsub (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regsub");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("regsub", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_rename (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::rename");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("rename", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_return (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::return");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("return", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_scan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::scan");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("scan", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_seek (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::seek");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("seek", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_set (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::set");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("set", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_socket (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::socket");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("socket", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_source (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::source");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("source", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_split (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::split");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("split", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_string (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::string");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("string", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_subst (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::subst");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("subst", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_switch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::switch");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("switch", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_tailcall (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tailcall");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("tailcall", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_tell (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tell");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("tell", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_time (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::time");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("time", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_trace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::trace");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("trace", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_try (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::try");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("try", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_unload (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unload");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("unload", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_unset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unset");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("unset", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_update (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::update");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("update", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_uplevel (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::uplevel");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("uplevel", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_upvar (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::upvar");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("upvar", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_variable (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::variable");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("variable", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_vwait (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::vwait");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("vwait", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_while (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::while");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("while", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_yield (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yield");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("yield", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_yieldto (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yieldto");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("yieldto", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_zlib (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::zlib");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("zlib", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+
diff --git a/native/clang/cvs/TSP_cmd.2022-04-28_18-24.c b/native/clang/cvs/TSP_cmd.2022-04-28_18-24.c
new file mode 100755
index 0000000..511819d
--- /dev/null
+++ b/native/clang/cvs/TSP_cmd.2022-04-28_18-24.c
@@ -0,0 +1,1683 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+/* return a pointer to a user direct command function, assumes
+   that user command puts the inner direct command into clientdata */
+
+void*
+TSP_User_getCmd(Tcl_Interp* interp, char* cmd) {
+    Tcl_CmdInfo cmdInfo;
+    int rc;
+    Tcl_ObjCmdProc* objCmd;
+    void* userCmd = NULL;
+    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
+    if (rc == 0) {
+        Tcl_Panic("TSP_User_getCmd: can't get command proc for %s", cmd);
+    } else {
+        objCmd = cmdInfo.objProc;
+        rc = objCmd(&userCmd, interp, 0, NULL);
+    }
+     return userCmd;
+}
+
+/* return a pointer to a Tcl command info */
+/* cmd info data is not preserved across multiple calls */
+
+Tcl_CmdInfo*
+TSP_Cmd_getCmdInfo(Tcl_Interp* interp, char* cmd) {
+    static Tcl_CmdInfo cmdInfo;
+    int rc;
+    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
+    if (rc == 0) {
+        Tcl_Panic("TSP_Cmd_getCmdInfo: can't get command proc for %s", cmd);
+    }
+     return &cmdInfo;
+}
+
+
+/* builtins command - a function that calls the builtin and fills in command obj name */
+
+int
+TSP_Cmd_builtin_after (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::after");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("after", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_append (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::append");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("append", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_apply (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::apply");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("apply", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_array (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::array");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("array", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_binary (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::binary");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("binary", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_break (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::break");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("break", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_case (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::case");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("case", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_catch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::catch");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("catch", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_cd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::cd");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("cd", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_chan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::chan");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("chan", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_clock (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    static int result;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::clock");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("clock", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    // somehow we have to reset the proc, or this risks to crash
+    result= (cmdProc)(clientData, interp, objc, objv);
+    cmdProc = NULL;
+    return result;
+}
+
+int
+TSP_Cmd_builtin_close (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::close");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("close", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_concat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::concat");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("concat", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_continue (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::continue");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("continue", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_dict (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::dict");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("dict", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_encoding (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::encoding");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("encoding", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_eof (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eof");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("eof", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_error (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::error");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("error", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_eval (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eval");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("eval", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_exec (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exec");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("exec", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_exit (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exit");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("exit", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_expr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::expr");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("expr", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_fblocked (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fblocked");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fblocked", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_fconfigure (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fconfigure");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fconfigure", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_fcopy (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fcopy");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fcopy", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_file (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::file");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("file", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_fileevent (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fileevent");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fileevent", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_flush (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::flush");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("flush", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_for (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::for");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("for", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_foreach (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::foreach");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("foreach", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_format (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::format");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("format", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_gets (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::gets");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("gets", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_glob (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::glob");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("glob", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_global (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::global");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("global", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_if (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::if");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("if", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_incr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::incr");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("incr", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_info (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::info");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("info", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_interp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::interp");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("interp", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_join (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::join");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("join", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lappend (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lappend");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lappend", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lassign (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lassign");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lassign", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lindex (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lindex");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lindex", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_linsert (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::linsert");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("linsert", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_list (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::list");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("list", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_llength (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::llength");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("llength", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lmap (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lmap");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lmap", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_load (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::load");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("load", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lrange (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrange");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lrange", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lrepeat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrepeat");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lrepeat", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lreplace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreplace");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lreplace", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lreverse (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreverse");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lreverse", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lsearch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsearch");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lsearch", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lset");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lset", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_lsort (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsort");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lsort", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_namespace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::namespace");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("namespace", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_open (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::open");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("open", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_package (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::package");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("package", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_pid (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pid");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("pid", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_proc (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::proc");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("proc", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_puts (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::puts");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("puts", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_pwd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pwd");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("pwd", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_read (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::read");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("read", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_regexp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regexp");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("regexp", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_regsub (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regsub");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("regsub", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_rename (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::rename");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("rename", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_return (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::return");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("return", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_scan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::scan");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("scan", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_seek (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::seek");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("seek", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_set (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::set");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("set", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_socket (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::socket");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("socket", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_source (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::source");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("source", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_split (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::split");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("split", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_string (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::string");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("string", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_subst (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::subst");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("subst", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_switch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::switch");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("switch", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_tailcall (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tailcall");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("tailcall", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_tell (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tell");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("tell", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_time (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::time");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("time", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_trace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::trace");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("trace", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_try (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::try");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("try", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_unload (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unload");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("unload", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_unset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unset");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("unset", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_update (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::update");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("update", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_uplevel (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::uplevel");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("uplevel", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_upvar (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::upvar");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("upvar", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_variable (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::variable");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("variable", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_vwait (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::vwait");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("vwait", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_while (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::while");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("while", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_yield (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yield");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("yield", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_yieldto (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yieldto");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("yieldto", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+int
+TSP_Cmd_builtin_zlib (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::zlib");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("zlib", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+
diff --git a/native/clang/cvs/TSP_cmd.2022-07-01_14-56.c b/native/clang/cvs/TSP_cmd.2022-07-01_14-56.c
new file mode 100755
index 0000000..d3bd013
--- /dev/null
+++ b/native/clang/cvs/TSP_cmd.2022-07-01_14-56.c
@@ -0,0 +1,1683 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+/* return a pointer to a user direct command function, assumes
+   that user command puts the inner direct command into clientdata */
+
+void*
+TSP_User_getCmd(Tcl_Interp* interp, char* cmd) {
+    Tcl_CmdInfo cmdInfo;
+    int rc;
+    Tcl_ObjCmdProc* objCmd;
+    void* userCmd = NULL;
+    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
+    if (rc == 0) {
+        Tcl_Panic("TSP_User_getCmd: can't get command proc for %s", cmd);
+    } else {
+        objCmd = cmdInfo.objProc;
+        rc = objCmd(&userCmd, interp, 0, NULL);
+    }
+     return userCmd;
+}
+
+/* return a pointer to a Tcl command info */
+/* cmd info data is not preserved across multiple calls */
+
+Tcl_CmdInfo*
+TSP_Cmd_getCmdInfo(Tcl_Interp* interp, char* cmd) {
+    static Tcl_CmdInfo cmdInfo;
+    int rc;
+    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
+    if (rc == 0) {
+        Tcl_Panic("TSP_Cmd_getCmdInfo: can't get command proc for %s", cmd);
+    }
+     return &cmdInfo;
+}
+
+
+/* builtins command - a function that calls the builtin and fills in command obj name */
+
+static inline int
+TSP_Cmd_builtin_after (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::after");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("after", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_append (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::append");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("append", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_apply (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::apply");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("apply", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_array (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::array");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("array", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_binary (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::binary");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("binary", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_break (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::break");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("break", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_case (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::case");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("case", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_catch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::catch");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("catch", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_cd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::cd");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("cd", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_chan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::chan");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("chan", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_clock (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    static int result;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::clock");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("clock", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    // somehow we have to reset the proc, or this risks to crash
+    result= (cmdProc)(clientData, interp, objc, objv);
+    cmdProc = NULL;
+    return result;
+}
+
+static inline int
+TSP_Cmd_builtin_close (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::close");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("close", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_concat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::concat");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("concat", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_continue (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::continue");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("continue", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_dict (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::dict");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("dict", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_encoding (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::encoding");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("encoding", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_eof (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eof");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("eof", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_error (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::error");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("error", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_eval (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eval");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("eval", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_exec (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exec");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("exec", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_exit (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exit");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("exit", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_expr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::expr");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("expr", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_fblocked (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fblocked");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fblocked", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_fconfigure (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fconfigure");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fconfigure", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_fcopy (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fcopy");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fcopy", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_file (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::file");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("file", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_fileevent (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fileevent");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fileevent", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_flush (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::flush");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("flush", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_for (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::for");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("for", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_foreach (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::foreach");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("foreach", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_format (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::format");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("format", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_gets (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::gets");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("gets", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_glob (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::glob");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("glob", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_global (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::global");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("global", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_if (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::if");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("if", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_incr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::incr");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("incr", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_info (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::info");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("info", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_interp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::interp");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("interp", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_join (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::join");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("join", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_lappend (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lappend");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lappend", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_lassign (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lassign");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lassign", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_lindex (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lindex");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lindex", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_linsert (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::linsert");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("linsert", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_list (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::list");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("list", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_llength (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::llength");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("llength", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_lmap (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lmap");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lmap", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_load (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::load");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("load", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_lrange (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrange");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lrange", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_lrepeat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrepeat");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lrepeat", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_lreplace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreplace");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lreplace", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_lreverse (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreverse");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lreverse", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_lsearch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsearch");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lsearch", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_lset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lset");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lset", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_lsort (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsort");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lsort", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_namespace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::namespace");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("namespace", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_open (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::open");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("open", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_package (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::package");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("package", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_pid (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pid");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("pid", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_proc (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::proc");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("proc", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_puts (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::puts");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("puts", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_pwd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pwd");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("pwd", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_read (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::read");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("read", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_regexp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regexp");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("regexp", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_regsub (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regsub");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("regsub", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_rename (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::rename");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("rename", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_return (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::return");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("return", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_scan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::scan");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("scan", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_seek (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::seek");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("seek", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_set (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::set");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("set", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_socket (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::socket");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("socket", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_source (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::source");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("source", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_split (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::split");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("split", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_string (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::string");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("string", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_subst (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::subst");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("subst", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_switch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::switch");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("switch", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_tailcall (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tailcall");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("tailcall", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_tell (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tell");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("tell", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_time (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::time");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("time", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_trace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::trace");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("trace", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_try (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::try");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("try", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_unload (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unload");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("unload", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_unset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unset");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("unset", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_update (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::update");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("update", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_uplevel (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::uplevel");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("uplevel", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_upvar (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::upvar");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("upvar", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_variable (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::variable");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("variable", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_vwait (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::vwait");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("vwait", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_while (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::while");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("while", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_yield (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yield");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("yield", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_yieldto (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yieldto");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("yieldto", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+static inline int
+TSP_Cmd_builtin_zlib (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::zlib");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("zlib", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+
diff --git a/native/clang/cvs/TSP_cmd.2022-07-01_16-28.c b/native/clang/cvs/TSP_cmd.2022-07-01_16-28.c
new file mode 100755
index 0000000..e587ea3
--- /dev/null
+++ b/native/clang/cvs/TSP_cmd.2022-07-01_16-28.c
@@ -0,0 +1,1689 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+/* return a pointer to a user direct command function, assumes
+   that user command puts the inner direct command into clientdata */
+
+void*
+TSP_User_getCmd(Tcl_Interp* interp, char* cmd) {
+    Tcl_CmdInfo cmdInfo;
+    int rc;
+    Tcl_ObjCmdProc* objCmd;
+    void* userCmd = NULL;
+    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
+    if (rc == 0) {
+        Tcl_Panic("TSP_User_getCmd: can't get command proc for %s", cmd);
+    } else {
+        objCmd = cmdInfo.objProc;
+        rc = objCmd(&userCmd, interp, 0, NULL);
+    }
+     return userCmd;
+}
+
+/* return a pointer to a Tcl command info */
+/* cmd info data is not preserved across multiple calls */
+
+Tcl_CmdInfo*
+TSP_Cmd_getCmdInfo(Tcl_Interp* interp, char* cmd) {
+    static Tcl_CmdInfo cmdInfo;
+    int rc;
+    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
+    if (rc == 0) {
+        Tcl_Panic("TSP_Cmd_getCmdInfo: can't get command proc for %s", cmd);
+    }
+     return &cmdInfo;
+}
+
+/* define TSP_REMOVABLE as static inline     to enable tcc dead code elimination */
+#ifdef __TINYC__
+#define TSP_REMOVABLE static inline 
+#else
+#define TSP_REMOVABLE static
+#endif
+
+/* builtins command - a function that calls the builtin and fills in command obj name */
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_after (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::after");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("after", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_append (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::append");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("append", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_apply (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::apply");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("apply", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_array (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::array");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("array", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_binary (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::binary");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("binary", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_break (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::break");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("break", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_case (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::case");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("case", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_catch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::catch");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("catch", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_cd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::cd");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("cd", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_chan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::chan");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("chan", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_clock (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    static int result;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::clock");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("clock", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    // somehow we have to reset the proc, or this risks to crash
+    result= (cmdProc)(clientData, interp, objc, objv);
+    cmdProc = NULL;
+    return result;
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_close (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::close");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("close", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_concat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::concat");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("concat", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_continue (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::continue");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("continue", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_dict (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::dict");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("dict", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_encoding (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::encoding");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("encoding", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_eof (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eof");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("eof", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_error (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::error");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("error", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_eval (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eval");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("eval", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_exec (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exec");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("exec", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_exit (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exit");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("exit", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_expr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::expr");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("expr", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_fblocked (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fblocked");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fblocked", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_fconfigure (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fconfigure");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fconfigure", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_fcopy (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fcopy");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fcopy", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_file (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::file");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("file", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_fileevent (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fileevent");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("fileevent", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_flush (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::flush");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("flush", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_for (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::for");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("for", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_foreach (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::foreach");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("foreach", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_format (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::format");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("format", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_gets (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::gets");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("gets", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_glob (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::glob");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("glob", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_global (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::global");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("global", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_if (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::if");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("if", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_incr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::incr");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("incr", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_info (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::info");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("info", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_interp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::interp");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("interp", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_join (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::join");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("join", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_lappend (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lappend");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lappend", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_lassign (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lassign");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lassign", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_lindex (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lindex");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lindex", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_linsert (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::linsert");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("linsert", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_list (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::list");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("list", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_llength (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::llength");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("llength", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_lmap (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lmap");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lmap", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_load (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::load");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("load", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_lrange (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrange");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lrange", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_lrepeat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrepeat");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lrepeat", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_lreplace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreplace");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lreplace", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_lreverse (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreverse");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lreverse", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_lsearch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsearch");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lsearch", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_lset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lset");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lset", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_lsort (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsort");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("lsort", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_namespace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::namespace");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("namespace", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_open (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::open");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("open", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_package (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::package");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("package", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_pid (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pid");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("pid", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_proc (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::proc");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("proc", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_puts (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::puts");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("puts", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_pwd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pwd");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("pwd", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_read (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::read");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("read", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_regexp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regexp");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("regexp", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_regsub (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regsub");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("regsub", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_rename (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::rename");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("rename", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_return (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::return");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("return", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_scan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::scan");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("scan", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_seek (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::seek");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("seek", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_set (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::set");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("set", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_socket (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::socket");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("socket", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_source (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::source");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("source", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_split (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::split");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("split", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_string (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::string");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("string", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_subst (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::subst");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("subst", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_switch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::switch");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("switch", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_tailcall (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tailcall");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("tailcall", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_tell (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tell");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("tell", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_time (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::time");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("time", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_trace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::trace");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("trace", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_try (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::try");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("try", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_unload (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unload");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("unload", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_unset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unset");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("unset", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_update (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::update");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("update", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_uplevel (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::uplevel");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("uplevel", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_upvar (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::upvar");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("upvar", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_variable (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::variable");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("variable", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_vwait (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::vwait");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("vwait", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_while (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::while");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("while", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_yield (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yield");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("yield", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_yieldto (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yieldto");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("yieldto", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+TSP_REMOVABLE int
+TSP_Cmd_builtin_zlib (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
+    static Tcl_ObjCmdProc* cmdProc = NULL;
+    static Tcl_Obj* cmdName = NULL;
+    static ClientData clientData = NULL;
+    if (cmdProc == NULL) {
+        Tcl_CmdInfo* cmdInfo;
+        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::zlib");
+        cmdProc = cmdInfo->objProc;
+        clientData = cmdInfo->objClientData;
+        cmdName = Tcl_NewStringObj("zlib", -1);
+        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
+        Tcl_IncrRefCount(cmdName);  /* from altercation  */
+    }
+    objv[0] = cmdName;
+    return (cmdProc)(clientData, interp, objc, objv);
+}
+
+
diff --git a/native/clang/cvs/TSP_func.2022-04-23_07-49.c b/native/clang/cvs/TSP_func.2022-04-23_07-49.c
new file mode 100755
index 0000000..8c0b5bc
--- /dev/null
+++ b/native/clang/cvs/TSP_func.2022-04-23_07-49.c
@@ -0,0 +1,426 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+#ifndef _MATH_H
+#include <math.h>
+#endif
+#include <stdlib.h>
+
+#ifndef _LIBC_LIMITS_H_
+#include <limits.h>
+#endif
+
+
+#define TRUE 1
+#define FALSE 0
+#define TSP_DIV_BY_ZERO "divide by zero"
+#define TSP_DOMAIN_ERROR "domain error"
+
+/* only record the first error */
+#define RAISE_ERROR(m) *rc = TCL_ERROR; if (*exprErrMsg == NULL) *exprErrMsg = m; return 0
+
+#define CHECK_NAN(a) if (isnan(a)) return NAN
+
+/* functions that can raise errors have macros to add rc and exprErrMsg parameters */
+
+#define TSP_func_int_div(a,b) _TSP_func_int_div(rc, &exprErrMsg, (a), (b))
+Tcl_WideInt
+_TSP_func_int_div(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
+    Tcl_WideInt quotient;
+
+    if (divisor == 0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " IntDiv()");
+    }
+    if (dividend == LLONG_MIN && divisor == -1) {
+        /* Avoid integer overflow on (Long.MIN_VALUE / -1) */
+        quotient = LLONG_MIN;
+    } else {
+        quotient = dividend / divisor;
+        /* Round down to a smaller negative number if  */
+        /* there is a remainder and the quotient is    */
+        /* negative or zero and the signs don't match. */
+        if (((quotient < 0) || ((quotient == 0) && (((dividend < 0) && (divisor > 0)) || ((dividend > 0)
+                    && (divisor < 0))))) && ((quotient * divisor) != dividend)) {
+            quotient -= 1;
+        }
+    }
+    return quotient;
+}
+
+
+#define TSP_func_int_mod(a,b) _TSP_func_int_mod(rc, &exprErrMsg, (a), (b))
+Tcl_WideInt
+_TSP_func_int_mod(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
+    Tcl_WideInt remainder = 0;
+    int neg_divisor = 0;
+
+    if (divisor == 0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " IntMod()");
+    }
+
+    if (dividend == LLONG_MIN && divisor == -1) {
+        remainder = 0;
+    } else {
+        if (divisor < 0) {
+            divisor = -divisor;
+            dividend = -dividend;
+            neg_divisor = 1;
+        }
+        remainder = dividend % divisor;
+        if (remainder < 0
+                && !(neg_divisor && (dividend == LLONG_MIN))) {
+            remainder += divisor;
+        }
+    }
+    if ((neg_divisor && (remainder > 0))
+                || (!neg_divisor && (remainder < 0))) {
+        remainder = -remainder;
+    }
+    return remainder;
+}
+
+
+#define TSP_func_double_div(a,b) _TSP_func_double_div(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_double_div(int* rc, char** exprErrMsg, double x, double y) {
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    if (y == 0.0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " DoubleDiv()");
+    } else {
+        return x / y;
+    }
+}
+
+int
+TSP_func_util_strcmp(Tcl_DString* s1, Tcl_DString* s2) {
+    int match;
+    int length1 = Tcl_DStringLength(s1);
+    int length2 = Tcl_DStringLength(s2);
+    length1 = Tcl_NumUtfChars(Tcl_DStringValue(s1), length1);
+    length2 = Tcl_NumUtfChars(Tcl_DStringValue(s2), length2);
+    match = Tcl_UtfNcmp(Tcl_DStringValue(s1), Tcl_DStringValue(s2), (length1 < length2) ? length1 : length2);
+    if (match == 0) {
+        return length1 - length2;
+    } else {
+        return match;
+    }
+}
+
+int
+TSP_func_str_lt(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) < 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_gt(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) > 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_le(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) <= 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_ge(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) >= 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_eq(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) == 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_ne(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) != 0) ? TRUE : FALSE;
+}
+
+Tcl_WideInt
+TSP_func_int_abs(Tcl_WideInt i) {
+    if (i < 0) {
+        if (i == LLONG_MIN) {
+            return 0;
+        } else {
+            return i * -1;
+        }
+    } else {
+        return i;
+    }
+}
+
+double
+TSP_func_double_abs(double x) {
+    CHECK_NAN(x);
+    if (x < 0) {
+        return x * -1.0;
+    } else {
+        return x;
+    }
+}
+
+#define TSP_func_acos(a)  _TSP_func_acos(rc, &exprErrMsg, (a))
+double
+_TSP_func_acos(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = acos(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " acos()");
+    }
+    return z;
+}
+
+#define TSP_func_asin(a) _TSP_func_asin(rc, &exprErrMsg, (a))
+double
+_TSP_func_asin(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = asin(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " asin()");
+    }
+    return z;
+}
+
+#define TSP_func_atan(a) _TSP_func_atan(rc, &exprErrMsg, (a))
+double
+_TSP_func_atan(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = atan(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " atan()");
+    }
+    return z;
+}
+
+#define TSP_func_atan2(a,b) _TSP_func_atan2(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_atan2(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = atan2(x, y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " atan2()");
+    }
+    return z;
+}
+
+#define TSP_func_ceil(a)  _TSP_func_ceil(rc, &exprErrMsg, (a))
+double
+_TSP_func_ceil(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = ceil(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " ceil()");
+    }
+    return z;
+}
+
+#define TSP_func_cos(a) _TSP_func_cos(rc, &exprErrMsg, (a))
+double
+_TSP_func_cos(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = cos(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " cos()");
+    }
+    return z;
+}
+
+#define TSP_func_cosh(a) _TSP_func_cosh(rc, &exprErrMsg, (a))
+double
+_TSP_func_cosh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = cosh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " cosh()");
+    }
+    return z;
+}
+
+#define TSP_func_exp(a) _TSP_func_exp(rc, &exprErrMsg, (a))
+double
+_TSP_func_exp(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = exp(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " exp()");
+    }
+    return z;
+}
+
+#define TSP_func_floor(a) _TSP_func_floor(rc, &exprErrMsg, (a))
+double
+_TSP_func_floor(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = floor(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " floor()");
+    }
+    return z;
+}
+
+#define TSP_func_fmod(a) _TSP_func_fmod(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_fmod(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = fmod(x, y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " fmod()");
+    }
+    return z;
+}
+
+#define TSP_func_hypot(a,b) _TSP_func_hypot(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_hypot(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = hypot(x, y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " hypot()");
+    }
+    return z;
+}
+
+#define TSP_func_log(a) _TSP_func_log(rc, &exprErrMsg, (a))
+double
+_TSP_func_log(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = log(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " log()");
+    }
+    return z;
+}
+
+#define TSP_func_log10(a) _TSP_func_log10(rc, &exprErrMsg, (a))
+double
+_TSP_func_log10(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = log(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " log10()");
+    }
+    return z;
+}
+
+#define TSP_func_pow(a,b) _TSP_func_pow(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = pow(x, y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
+    }
+    return z;
+}
+
+#define TSP_func_int_pow(a,b) _TSP_func_int_pow(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
+    double z;
+    CHECK_NAN(x);
+    z = pow(x, (double) y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
+    }
+    return z;
+}
+
+
+double
+TSP_func_rand() {
+    return rand(); 
+}
+
+double
+TSP_func_round(double x) {
+    return round(x);
+}
+
+#define TSP_func_sin(a) _TSP_func_sin(rc, &exprErrMsg, (a))
+double
+_TSP_func_sin(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sin(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sin()");
+    }
+    return z;
+}
+
+#define TSP_func_sinh(a) _TSP_func_sinh(rc, &exprErrMsg, (a))
+double
+_TSP_func_sinh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sinh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sinh()");
+    }
+    return z;
+}
+
+#define TSP_func_sqrt(a) _TSP_func_sqrt(rc, &exprErrMsg, (a))
+double
+_TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sqrt(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sqrt()");
+    }
+    return z;
+}
+
+double
+TSP_func_int_srand(Tcl_WideInt i) {
+    srand((long) i);
+    return rand();
+}
+
+#define TSP_func_tan(a) _TSP_func_tan(rc, &exprErrMsg, (a))
+double
+_TSP_func_tan(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = tan(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " tan()");
+    }
+    return z;
+}
+
+#define TSP_func_tanh(a) _TSP_func_tanh(rc, &exprErrMsg, (a))
+double
+_TSP_func_tanh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = tanh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " tanh()");
+    }
+    return z;
+}
+
+
+
diff --git a/native/clang/cvs/TSP_func.2022-04-25_14-34.c b/native/clang/cvs/TSP_func.2022-04-25_14-34.c
new file mode 100755
index 0000000..cd29697
--- /dev/null
+++ b/native/clang/cvs/TSP_func.2022-04-25_14-34.c
@@ -0,0 +1,461 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+#ifndef _MATH_H
+#include <math.h>
+#endif
+#include <stdlib.h>
+
+#ifndef _LIBC_LIMITS_H_
+#include <limits.h>
+#endif
+
+
+#define TRUE 1
+#define FALSE 0
+#define TSP_DIV_BY_ZERO "divide by zero"
+#define TSP_DOMAIN_ERROR "domain error"
+
+/* only record the first error */
+#define RAISE_ERROR(m) *rc = TCL_ERROR; if (*exprErrMsg == NULL) *exprErrMsg = m; return 0
+
+#define CHECK_NAN(a) if (isnan(a)) return NAN
+
+/* functions that can raise errors have macros to add rc and exprErrMsg parameters */
+
+#define TSP_func_int_div(a,b) _TSP_func_int_div(rc, &exprErrMsg, (a), (b))
+Tcl_WideInt
+_TSP_func_int_div(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
+    Tcl_WideInt quotient;
+
+    if (divisor == 0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " IntDiv()");
+    }
+    if (dividend == LLONG_MIN && divisor == -1) {
+        /* Avoid integer overflow on (Long.MIN_VALUE / -1) */
+        quotient = LLONG_MIN;
+    } else {
+        quotient = dividend / divisor;
+        /* Round down to a smaller negative number if  */
+        /* there is a remainder and the quotient is    */
+        /* negative or zero and the signs don't match. */
+        if (((quotient < 0) || ((quotient == 0) && (((dividend < 0) && (divisor > 0)) || ((dividend > 0)
+                    && (divisor < 0))))) && ((quotient * divisor) != dividend)) {
+            quotient -= 1;
+        }
+    }
+    return quotient;
+}
+
+
+#define TSP_func_int_mod(a,b) _TSP_func_int_mod(rc, &exprErrMsg, (a), (b))
+Tcl_WideInt
+_TSP_func_int_mod(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
+    Tcl_WideInt remainder = 0;
+    int neg_divisor = 0;
+
+    if (divisor == 0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " IntMod()");
+    }
+
+    if (dividend == LLONG_MIN && divisor == -1) {
+        remainder = 0;
+    } else {
+        if (divisor < 0) {
+            divisor = -divisor;
+            dividend = -dividend;
+            neg_divisor = 1;
+        }
+        remainder = dividend % divisor;
+        if (remainder < 0
+                && !(neg_divisor && (dividend == LLONG_MIN))) {
+            remainder += divisor;
+        }
+    }
+    if ((neg_divisor && (remainder > 0))
+                || (!neg_divisor && (remainder < 0))) {
+        remainder = -remainder;
+    }
+    return remainder;
+}
+
+
+#define TSP_func_double_div(a,b) _TSP_func_double_div(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_double_div(int* rc, char** exprErrMsg, double x, double y) {
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    if (y == 0.0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " DoubleDiv()");
+    } else {
+        return x / y;
+    }
+}
+
+int
+TSP_func_util_strcmp(Tcl_DString* s1, Tcl_DString* s2) {
+    int match;
+    int length1 = Tcl_DStringLength(s1);
+    int length2 = Tcl_DStringLength(s2);
+    length1 = Tcl_NumUtfChars(Tcl_DStringValue(s1), length1);
+    length2 = Tcl_NumUtfChars(Tcl_DStringValue(s2), length2);
+    match = Tcl_UtfNcmp(Tcl_DStringValue(s1), Tcl_DStringValue(s2), (length1 < length2) ? length1 : length2);
+    if (match == 0) {
+        return length1 - length2;
+    } else {
+        return match;
+    }
+}
+
+int
+TSP_func_str_lt(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) < 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_gt(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) > 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_le(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) <= 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_ge(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) >= 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_eq(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) == 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_ne(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) != 0) ? TRUE : FALSE;
+}
+
+Tcl_WideInt
+TSP_func_int_abs(Tcl_WideInt i) {
+    if (i < 0) {
+        if (i == LLONG_MIN) {
+            return 0;
+        } else {
+            return i * -1;
+        }
+    } else {
+        return i;
+    }
+}
+
+double
+TSP_func_double_abs(double x) {
+    CHECK_NAN(x);
+    if (x < 0) {
+        return x * -1.0;
+    } else {
+        return x;
+    }
+}
+
+#define TSP_func_acos(a)  _TSP_func_acos(rc, &exprErrMsg, (a))
+double
+_TSP_func_acos(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = acos(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " acos()");
+    }
+    return z;
+}
+
+#define TSP_func_asin(a) _TSP_func_asin(rc, &exprErrMsg, (a))
+double
+_TSP_func_asin(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = asin(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " asin()");
+    }
+    return z;
+}
+
+#define TSP_func_atan(a) _TSP_func_atan(rc, &exprErrMsg, (a))
+double
+_TSP_func_atan(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = atan(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " atan()");
+    }
+    return z;
+}
+
+#define TSP_func_atan2(a,b) _TSP_func_atan2(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_atan2(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = atan2(x, y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " atan2()");
+    }
+    return z;
+}
+
+#define TSP_func_ceil(a)  _TSP_func_ceil(rc, &exprErrMsg, (a))
+double
+_TSP_func_ceil(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = ceil(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " ceil()");
+    }
+    return z;
+}
+
+#define TSP_func_cos(a) _TSP_func_cos(rc, &exprErrMsg, (a))
+double
+_TSP_func_cos(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = cos(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " cos()");
+    }
+    return z;
+}
+
+#define TSP_func_cosh(a) _TSP_func_cosh(rc, &exprErrMsg, (a))
+double
+_TSP_func_cosh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = cosh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " cosh()");
+    }
+    return z;
+}
+
+#define TSP_func_exp(a) _TSP_func_exp(rc, &exprErrMsg, (a))
+double
+_TSP_func_exp(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = exp(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " exp()");
+    }
+    return z;
+}
+
+#define TSP_func_floor(a) _TSP_func_floor(rc, &exprErrMsg, (a))
+double
+_TSP_func_floor(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = floor(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " floor()");
+    }
+    return z;
+}
+
+#define TSP_func_fmod(a) _TSP_func_fmod(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_fmod(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = fmod(x, y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " fmod()");
+    }
+    return z;
+}
+
+#define TSP_func_hypot(a,b) _TSP_func_hypot(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_hypot(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = hypot(x, y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " hypot()");
+    }
+    return z;
+}
+
+#define TSP_func_log(a) _TSP_func_log(rc, &exprErrMsg, (a))
+double
+_TSP_func_log(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = log(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " log()");
+    }
+    return z;
+}
+
+#define TSP_func_log10(a) _TSP_func_log10(rc, &exprErrMsg, (a))
+double
+_TSP_func_log10(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = log(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " log10()");
+    }
+    return z;
+}
+
+#define max(a,b) \
+   ({ __typeof__ (a) _a = (a); \
+       __typeof__ (b) _b = (b); \
+     _a > _b ? _a : _b; })
+#define TSP_func_max(a,b)  _TSP_func_max(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_max(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = max(x,y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " max()");
+    }
+    return z;
+}
+
+#define min(a,b) \
+   ({ __typeof__ (a) _a = (a); \
+       __typeof__ (b) _b = (b); \
+     _a <= _b ? _a : _b; })
+#define TSP_func_min(a,b)  _TSP_func_min(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_min(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = min(x,y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " min()");
+    }
+    return z;
+}
+
+#define TSP_func_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
+#define TSP_func_double_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = pow(x, y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
+    }
+    return z;
+}
+
+#define TSP_func_int_pow(a,b) _TSP_func_double_int_pow(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
+    double z;
+    CHECK_NAN(x);
+    z = pow(x, (double) y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
+    }
+    return z;
+}
+
+
+double
+TSP_func_rand() {
+    return rand(); 
+}
+
+double
+TSP_func_round(double x) {
+    return round(x);
+}
+
+#define TSP_func_sin(a) _TSP_func_sin(rc, &exprErrMsg, (a))
+double
+_TSP_func_sin(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sin(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sin()");
+    }
+    return z;
+}
+
+#define TSP_func_sinh(a) _TSP_func_sinh(rc, &exprErrMsg, (a))
+double
+_TSP_func_sinh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sinh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sinh()");
+    }
+    return z;
+}
+
+#define TSP_func_sqrt(a) _TSP_func_sqrt(rc, &exprErrMsg, (a))
+double
+_TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sqrt(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sqrt()");
+    }
+    return z;
+}
+
+double
+TSP_func_int_srand(Tcl_WideInt i) {
+    srand((long) i);
+    return rand();
+}
+
+#define TSP_func_tan(a) _TSP_func_tan(rc, &exprErrMsg, (a))
+double
+_TSP_func_tan(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = tan(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " tan()");
+    }
+    return z;
+}
+
+#define TSP_func_tanh(a) _TSP_func_tanh(rc, &exprErrMsg, (a))
+double
+_TSP_func_tanh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = tanh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " tanh()");
+    }
+    return z;
+}
+
+
+
diff --git a/native/clang/cvs/TSP_func.2022-05-13_12-11.c b/native/clang/cvs/TSP_func.2022-05-13_12-11.c
new file mode 100755
index 0000000..7c3cd73
--- /dev/null
+++ b/native/clang/cvs/TSP_func.2022-05-13_12-11.c
@@ -0,0 +1,462 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+#ifndef _MATH_H
+#include <math.h>
+#endif
+#include <stdlib.h>
+
+#ifndef _LIBC_LIMITS_H_
+#include <limits.h>
+#endif
+
+
+#define TRUE 1
+#define FALSE 0
+#define TSP_DIV_BY_ZERO "divide by zero"
+#define TSP_DOMAIN_ERROR "domain error"
+
+/* only record the first error */
+#define RAISE_ERROR(m) *rc = TCL_ERROR; if (*exprErrMsg == NULL) *exprErrMsg = m; return 0
+
+#define CHECK_NAN(a) if (isnan(a)) return NAN
+
+/* functions that can raise errors have macros to add rc and exprErrMsg parameters */
+
+#define TSP_func_int_div(a,b) _TSP_func_int_div(rc, &exprErrMsg, (a), (b))
+Tcl_WideInt
+_TSP_func_int_div(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
+    Tcl_WideInt quotient;
+
+    if (divisor == 0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " IntDiv()");
+    }
+    if (dividend == LLONG_MIN && divisor == -1) {
+        /* Avoid integer overflow on (Long.MIN_VALUE / -1) */
+        quotient = LLONG_MIN;
+    } else {
+        quotient = dividend / divisor;
+        /* Round down to a smaller negative number if  */
+        /* there is a remainder and the quotient is    */
+        /* negative or zero and the signs don't match. */
+        if (((quotient < 0) || ((quotient == 0) && (((dividend < 0) && (divisor > 0)) || ((dividend > 0)
+                    && (divisor < 0))))) && ((quotient * divisor) != dividend)) {
+            quotient -= 1;
+        }
+    }
+    return quotient;
+}
+
+
+#define TSP_func_int_mod(a,b) _TSP_func_int_mod(rc, &exprErrMsg, (a), (b))
+Tcl_WideInt
+_TSP_func_int_mod(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
+    Tcl_WideInt remainder = 0;
+    int neg_divisor = 0;
+
+    if (divisor == 0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " IntMod()");
+    }
+
+    if (dividend == LLONG_MIN && divisor == -1) {
+        remainder = 0;
+    } else {
+        if (divisor < 0) {
+            divisor = -divisor;
+            dividend = -dividend;
+            neg_divisor = 1;
+        }
+        remainder = dividend % divisor;
+        if (remainder < 0
+                && !(neg_divisor && (dividend == LLONG_MIN))) {
+            remainder += divisor;
+        }
+    }
+    if ((neg_divisor && (remainder > 0))
+                || (!neg_divisor && (remainder < 0))) {
+        remainder = -remainder;
+    }
+    return remainder;
+}
+
+
+#define TSP_func_double_div(a,b) _TSP_func_double_div(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_double_div(int* rc, char** exprErrMsg, double x, double y) {
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    if (y == 0.0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " DoubleDiv()");
+    } else {
+        return x / y;
+    }
+}
+
+int
+TSP_func_util_strcmp(Tcl_DString* s1, Tcl_DString* s2) {
+    int match;
+    int length1 = Tcl_DStringLength(s1);
+    int length2 = Tcl_DStringLength(s2);
+    length1 = Tcl_NumUtfChars(Tcl_DStringValue(s1), length1);
+    length2 = Tcl_NumUtfChars(Tcl_DStringValue(s2), length2);
+    match = Tcl_UtfNcmp(Tcl_DStringValue(s1), Tcl_DStringValue(s2), (length1 < length2) ? length1 : length2);
+    if (match == 0) {
+        return length1 - length2;
+    } else {
+        return match;
+    }
+}
+
+int
+TSP_func_str_lt(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) < 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_gt(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) > 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_le(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) <= 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_ge(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) >= 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_eq(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) == 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_ne(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) != 0) ? TRUE : FALSE;
+}
+
+
+Tcl_WideInt
+TSP_func_int_abs(Tcl_WideInt i) {
+    if (i < 0) {
+        if (i == LLONG_MIN) {
+            return 0;
+        } else {
+            return i * -1;
+        }
+    } else {
+        return i;
+    }
+}
+
+double
+TSP_func_double_abs(double x) {
+    CHECK_NAN(x);
+    if (x < 0) {
+        return x * -1.0;
+    } else {
+        return x;
+    }
+}
+
+#define TSP_func_acos(a)  _TSP_func_acos(rc, &exprErrMsg, (a))
+double
+_TSP_func_acos(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = acos(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " acos()");
+    }
+    return z;
+}
+
+#define TSP_func_asin(a) _TSP_func_asin(rc, &exprErrMsg, (a))
+double
+_TSP_func_asin(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = asin(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " asin()");
+    }
+    return z;
+}
+
+#define TSP_func_atan(a) _TSP_func_atan(rc, &exprErrMsg, (a))
+double
+_TSP_func_atan(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = atan(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " atan()");
+    }
+    return z;
+}
+
+#define TSP_func_atan2(a,b) _TSP_func_atan2(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_atan2(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = atan2(x, y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " atan2()");
+    }
+    return z;
+}
+
+#define TSP_func_ceil(a)  _TSP_func_ceil(rc, &exprErrMsg, (a))
+double
+_TSP_func_ceil(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = ceil(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " ceil()");
+    }
+    return z;
+}
+
+#define TSP_func_cos(a) _TSP_func_cos(rc, &exprErrMsg, (a))
+double
+_TSP_func_cos(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = cos(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " cos()");
+    }
+    return z;
+}
+
+#define TSP_func_cosh(a) _TSP_func_cosh(rc, &exprErrMsg, (a))
+double
+_TSP_func_cosh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = cosh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " cosh()");
+    }
+    return z;
+}
+
+#define TSP_func_exp(a) _TSP_func_exp(rc, &exprErrMsg, (a))
+double
+_TSP_func_exp(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = exp(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " exp()");
+    }
+    return z;
+}
+
+#define TSP_func_floor(a) _TSP_func_floor(rc, &exprErrMsg, (a))
+double
+_TSP_func_floor(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = floor(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " floor()");
+    }
+    return z;
+}
+
+#define TSP_func_fmod(a) _TSP_func_fmod(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_fmod(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = fmod(x, y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " fmod()");
+    }
+    return z;
+}
+
+#define TSP_func_hypot(a,b) _TSP_func_hypot(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_hypot(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = hypot(x, y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " hypot()");
+    }
+    return z;
+}
+
+#define TSP_func_log(a) _TSP_func_log(rc, &exprErrMsg, (a))
+double
+_TSP_func_log(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = log(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " log()");
+    }
+    return z;
+}
+
+#define TSP_func_log10(a) _TSP_func_log10(rc, &exprErrMsg, (a))
+double
+_TSP_func_log10(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = log(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " log10()");
+    }
+    return z;
+}
+
+#define max(a,b) \
+   ({ __typeof__ (a) _a = (a); \
+       __typeof__ (b) _b = (b); \
+     _a > _b ? _a : _b; })
+#define TSP_func_max(a,b)  _TSP_func_max(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_max(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = max(x,y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " max()");
+    }
+    return z;
+}
+
+#define min(a,b) \
+   ({ __typeof__ (a) _a = (a); \
+       __typeof__ (b) _b = (b); \
+     _a <= _b ? _a : _b; })
+#define TSP_func_min(a,b)  _TSP_func_min(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_min(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = min(x,y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " min()");
+    }
+    return z;
+}
+
+#define TSP_func_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
+#define TSP_func_double_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = pow(x, y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
+    }
+    return z;
+}
+
+#define TSP_func_int_pow(a,b) _TSP_func_double_int_pow(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
+    double z;
+    CHECK_NAN(x);
+    z = pow(x, (double) y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
+    }
+    return z;
+}
+
+
+double
+TSP_func_rand() {
+    return rand(); 
+}
+
+double
+TSP_func_round(double x) {
+    return round(x);
+}
+
+#define TSP_func_sin(a) _TSP_func_sin(rc, &exprErrMsg, (a))
+double
+_TSP_func_sin(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sin(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sin()");
+    }
+    return z;
+}
+
+#define TSP_func_sinh(a) _TSP_func_sinh(rc, &exprErrMsg, (a))
+double
+_TSP_func_sinh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sinh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sinh()");
+    }
+    return z;
+}
+
+#define TSP_func_sqrt(a) _TSP_func_sqrt(rc, &exprErrMsg, (a))
+double
+_TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sqrt(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sqrt()");
+    }
+    return z;
+}
+
+double
+TSP_func_int_srand(Tcl_WideInt i) {
+    srand((long) i);
+    return rand();
+}
+
+#define TSP_func_tan(a) _TSP_func_tan(rc, &exprErrMsg, (a))
+double
+_TSP_func_tan(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = tan(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " tan()");
+    }
+    return z;
+}
+
+#define TSP_func_tanh(a) _TSP_func_tanh(rc, &exprErrMsg, (a))
+double
+_TSP_func_tanh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = tanh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " tanh()");
+    }
+    return z;
+}
+
+
+
diff --git a/native/clang/cvs/TSP_func.2022-05-16_19-15.c b/native/clang/cvs/TSP_func.2022-05-16_19-15.c
new file mode 100755
index 0000000..b0a8b28
--- /dev/null
+++ b/native/clang/cvs/TSP_func.2022-05-16_19-15.c
@@ -0,0 +1,464 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+#ifndef _MATH_H
+#include <math.h>
+#endif
+#include <stdlib.h>
+
+#ifndef _LIBC_LIMITS_H_
+#include <limits.h>
+#endif
+
+
+#define TRUE 1
+#define FALSE 0
+#define TSP_DIV_BY_ZERO "divide by zero"
+#define TSP_DOMAIN_ERROR "domain error"
+
+/* only record the first error */
+#define RAISE_ERROR(m) *rc = TCL_ERROR; if (*exprErrMsg == NULL) *exprErrMsg = m; return 0
+
+#define CHECK_NAN(a) if (isnan(a)) return NAN
+
+/* functions that can raise errors have macros to add rc and exprErrMsg parameters */
+
+#define TSP_func_int_div(a,b) _TSP_func_int_div(rc, &exprErrMsg, (a), (b))
+Tcl_WideInt
+_TSP_func_int_div(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
+    Tcl_WideInt quotient;
+
+    if (divisor == 0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " IntDiv()");
+    }
+    if (dividend == LLONG_MIN && divisor == -1) {
+        /* Avoid integer overflow on (Long.MIN_VALUE / -1) */
+        quotient = LLONG_MIN;
+    } else {
+        quotient = dividend / divisor;
+        /* Round down to a smaller negative number if  */
+        /* there is a remainder and the quotient is    */
+        /* negative or zero and the signs don't match. */
+        if (((quotient < 0) || ((quotient == 0) && (((dividend < 0) && (divisor > 0)) || ((dividend > 0)
+                    && (divisor < 0))))) && ((quotient * divisor) != dividend)) {
+            quotient -= 1;
+        }
+    }
+    return quotient;
+}
+
+
+#define TSP_func_int_mod(a,b) _TSP_func_int_mod(rc, &exprErrMsg, (a), (b))
+Tcl_WideInt
+_TSP_func_int_mod(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
+    Tcl_WideInt remainder = 0;
+    int neg_divisor = 0;
+
+    if (divisor == 0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " IntMod()");
+    }
+
+    if (dividend == LLONG_MIN && divisor == -1) {
+        remainder = 0;
+    } else {
+        if (divisor < 0) {
+            divisor = -divisor;
+            dividend = -dividend;
+            neg_divisor = 1;
+        }
+        remainder = dividend % divisor;
+        if (remainder < 0
+                && !(neg_divisor && (dividend == LLONG_MIN))) {
+            remainder += divisor;
+        }
+    }
+    if ((neg_divisor && (remainder > 0))
+                || (!neg_divisor && (remainder < 0))) {
+        remainder = -remainder;
+    }
+    return remainder;
+}
+
+
+#define TSP_func_double_div(a,b) _TSP_func_double_div(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_double_div(int* rc, char** exprErrMsg, double x, double y) {
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    if (y == 0.0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " DoubleDiv()");
+    } else {
+        return x / y;
+    }
+}
+
+int
+TSP_func_util_strcmp(Tcl_DString* s1, Tcl_DString* s2) {
+    int match;
+    int length1 = Tcl_DStringLength(s1);
+    int length2 = Tcl_DStringLength(s2);
+    length1 = Tcl_NumUtfChars(Tcl_DStringValue(s1), length1);
+    length2 = Tcl_NumUtfChars(Tcl_DStringValue(s2), length2);
+    match = Tcl_UtfNcmp(Tcl_DStringValue(s1), Tcl_DStringValue(s2), (length1 < length2) ? length1 : length2);
+    if (match == 0) {
+        return length1 - length2;
+    } else {
+        return match;
+    }
+}
+
+int
+TSP_func_str_lt(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) < 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_gt(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) > 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_le(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) <= 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_ge(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) >= 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_eq(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) == 0) ? TRUE : FALSE;
+}
+
+int
+TSP_func_str_ne(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) != 0) ? TRUE : FALSE;
+}
+
+
+Tcl_WideInt
+TSP_func_int_abs(Tcl_WideInt i) {
+    if (i < 0) {
+        if (i == LLONG_MIN) {
+            return 0;
+        } else {
+            return i * -1;
+        }
+    } else {
+        return i;
+    }
+}
+
+double
+TSP_func_double_abs(double x) {
+    CHECK_NAN(x);
+    if (x < 0) {
+        return x * -1.0;
+    } else {
+        return x;
+    }
+}
+
+#define TSP_func_acos(a)  _TSP_func_acos(rc, &exprErrMsg, (a))
+double
+_TSP_func_acos(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = acos(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " acos()");
+    }
+    return z;
+}
+
+#define TSP_func_asin(a) _TSP_func_asin(rc, &exprErrMsg, (a))
+double
+_TSP_func_asin(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = asin(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " asin()");
+    }
+    return z;
+}
+
+#define TSP_func_atan(a) _TSP_func_atan(rc, &exprErrMsg, (a))
+double
+_TSP_func_atan(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = atan(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " atan()");
+    }
+    return z;
+}
+
+#define TSP_func_atan2(a,b) _TSP_func_atan2(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_atan2(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = atan2(x, y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " atan2()");
+    }
+    return z;
+}
+
+#define TSP_func_ceil(a)  _TSP_func_ceil(rc, &exprErrMsg, (a))
+double
+_TSP_func_ceil(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = ceil(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " ceil()");
+    }
+    return z;
+}
+
+#define TSP_func_cos(a) _TSP_func_cos(rc, &exprErrMsg, (a))
+double
+_TSP_func_cos(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = cos(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " cos()");
+    }
+    return z;
+}
+
+#define TSP_func_cosh(a) _TSP_func_cosh(rc, &exprErrMsg, (a))
+double
+_TSP_func_cosh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = cosh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " cosh()");
+    }
+    return z;
+}
+
+#define TSP_func_exp(a) _TSP_func_exp(rc, &exprErrMsg, (a))
+double
+_TSP_func_exp(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = exp(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " exp()");
+    }
+    return z;
+}
+
+#define TSP_func_floor(a) _TSP_func_floor(rc, &exprErrMsg, (a))
+double
+_TSP_func_floor(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = floor(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " floor()");
+    }
+    return z;
+}
+
+#define TSP_func_fmod(a) _TSP_func_fmod(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_fmod(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = fmod(x, y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " fmod()");
+    }
+    return z;
+}
+
+#define TSP_func_hypot(a,b) _TSP_func_hypot(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_hypot(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = hypot(x, y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " hypot()");
+    }
+    return z;
+}
+
+#define TSP_func_log(a) _TSP_func_log(rc, &exprErrMsg, (a))
+double
+_TSP_func_log(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = log(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " log()");
+    }
+    return z;
+}
+
+#define TSP_func_log10(a) _TSP_func_log10(rc, &exprErrMsg, (a))
+double
+_TSP_func_log10(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = log(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " log10()");
+    }
+    return z;
+}
+#ifndef max
+#define max(a,b) \
+   ({ __typeof__ (a) _a = (a); \
+       __typeof__ (b) _b = (b); \
+     _a > _b ? _a : _b; })
+#endif
+#define TSP_func_max(a,b)  _TSP_func_max(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_max(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = max(x,y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " max()");
+    }
+    return z;
+}
+#ifndef min
+#define min(a,b) \
+   ({ __typeof__ (a) _a = (a); \
+       __typeof__ (b) _b = (b); \
+     _a <= _b ? _a : _b; })
+#endif
+#define TSP_func_min(a,b)  _TSP_func_min(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_min(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = min(x,y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " min()");
+    }
+    return z;
+}
+
+#define TSP_func_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
+#define TSP_func_double_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = pow(x, y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
+    }
+    return z;
+}
+
+#define TSP_func_int_pow(a,b) _TSP_func_double_int_pow(rc, &exprErrMsg, (a), (b))
+double
+_TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
+    double z;
+    CHECK_NAN(x);
+    z = pow(x, (double) y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
+    }
+    return z;
+}
+
+
+double
+TSP_func_rand() {
+    return rand(); 
+}
+
+double
+TSP_func_round(double x) {
+    return round(x);
+}
+
+#define TSP_func_sin(a) _TSP_func_sin(rc, &exprErrMsg, (a))
+double
+_TSP_func_sin(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sin(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sin()");
+    }
+    return z;
+}
+
+#define TSP_func_sinh(a) _TSP_func_sinh(rc, &exprErrMsg, (a))
+double
+_TSP_func_sinh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sinh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sinh()");
+    }
+    return z;
+}
+
+#define TSP_func_sqrt(a) _TSP_func_sqrt(rc, &exprErrMsg, (a))
+double
+_TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sqrt(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sqrt()");
+    }
+    return z;
+}
+
+double
+TSP_func_int_srand(Tcl_WideInt i) {
+    srand((long) i);
+    return rand();
+}
+
+#define TSP_func_tan(a) _TSP_func_tan(rc, &exprErrMsg, (a))
+double
+_TSP_func_tan(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = tan(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " tan()");
+    }
+    return z;
+}
+
+#define TSP_func_tanh(a) _TSP_func_tanh(rc, &exprErrMsg, (a))
+double
+_TSP_func_tanh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = tanh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " tanh()");
+    }
+    return z;
+}
+
+
+
diff --git a/native/clang/cvs/TSP_func.2022-07-01_14-53.c b/native/clang/cvs/TSP_func.2022-07-01_14-53.c
new file mode 100755
index 0000000..bea2263
--- /dev/null
+++ b/native/clang/cvs/TSP_func.2022-07-01_14-53.c
@@ -0,0 +1,464 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+#ifndef _MATH_H
+#include <math.h>
+#endif
+#include <stdlib.h>
+
+#ifndef _LIBC_LIMITS_H_
+#include <limits.h>
+#endif
+
+
+#define TRUE 1
+#define FALSE 0
+#define TSP_DIV_BY_ZERO "divide by zero"
+#define TSP_DOMAIN_ERROR "domain error"
+
+/* only record the first error */
+#define RAISE_ERROR(m) *rc = TCL_ERROR; if (*exprErrMsg == NULL) *exprErrMsg = m; return 0
+
+#define CHECK_NAN(a) if (isnan(a)) return NAN
+
+/* functions that can raise errors have macros to add rc and exprErrMsg parameters */
+
+#define TSP_func_int_div(a,b) _TSP_func_int_div(rc, &exprErrMsg, (a), (b))
+static inline Tcl_WideInt
+_TSP_func_int_div(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
+    Tcl_WideInt quotient;
+
+    if (divisor == 0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " IntDiv()");
+    }
+    if (dividend == LLONG_MIN && divisor == -1) {
+        /* Avoid integer overflow on (Long.MIN_VALUE / -1) */
+        quotient = LLONG_MIN;
+    } else {
+        quotient = dividend / divisor;
+        /* Round down to a smaller negative number if  */
+        /* there is a remainder and the quotient is    */
+        /* negative or zero and the signs don't match. */
+        if (((quotient < 0) || ((quotient == 0) && (((dividend < 0) && (divisor > 0)) || ((dividend > 0)
+                    && (divisor < 0))))) && ((quotient * divisor) != dividend)) {
+            quotient -= 1;
+        }
+    }
+    return quotient;
+}
+
+
+#define TSP_func_int_mod(a,b) _TSP_func_int_mod(rc, &exprErrMsg, (a), (b))
+static inline Tcl_WideInt
+_TSP_func_int_mod(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
+    Tcl_WideInt remainder = 0;
+    int neg_divisor = 0;
+
+    if (divisor == 0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " IntMod()");
+    }
+
+    if (dividend == LLONG_MIN && divisor == -1) {
+        remainder = 0;
+    } else {
+        if (divisor < 0) {
+            divisor = -divisor;
+            dividend = -dividend;
+            neg_divisor = 1;
+        }
+        remainder = dividend % divisor;
+        if (remainder < 0
+                && !(neg_divisor && (dividend == LLONG_MIN))) {
+            remainder += divisor;
+        }
+    }
+    if ((neg_divisor && (remainder > 0))
+                || (!neg_divisor && (remainder < 0))) {
+        remainder = -remainder;
+    }
+    return remainder;
+}
+
+
+#define TSP_func_double_div(a,b) _TSP_func_double_div(rc, &exprErrMsg, (a), (b))
+static inline double
+_TSP_func_double_div(int* rc, char** exprErrMsg, double x, double y) {
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    if (y == 0.0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " DoubleDiv()");
+    } else {
+        return x / y;
+    }
+}
+
+static inline int
+TSP_func_util_strcmp(Tcl_DString* s1, Tcl_DString* s2) {
+    int match;
+    int length1 = Tcl_DStringLength(s1);
+    int length2 = Tcl_DStringLength(s2);
+    length1 = Tcl_NumUtfChars(Tcl_DStringValue(s1), length1);
+    length2 = Tcl_NumUtfChars(Tcl_DStringValue(s2), length2);
+    match = Tcl_UtfNcmp(Tcl_DStringValue(s1), Tcl_DStringValue(s2), (length1 < length2) ? length1 : length2);
+    if (match == 0) {
+        return length1 - length2;
+    } else {
+        return match;
+    }
+}
+
+static inline int
+TSP_func_str_lt(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) < 0) ? TRUE : FALSE;
+}
+
+static inline int
+TSP_func_str_gt(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) > 0) ? TRUE : FALSE;
+}
+
+static inline int
+TSP_func_str_le(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) <= 0) ? TRUE : FALSE;
+}
+
+static inline int
+TSP_func_str_ge(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) >= 0) ? TRUE : FALSE;
+}
+
+static inline int
+TSP_func_str_eq(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) == 0) ? TRUE : FALSE;
+}
+
+static inline int
+TSP_func_str_ne(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) != 0) ? TRUE : FALSE;
+}
+
+
+static inline Tcl_WideInt
+TSP_func_int_abs(Tcl_WideInt i) {
+    if (i < 0) {
+        if (i == LLONG_MIN) {
+            return 0;
+        } else {
+            return i * -1;
+        }
+    } else {
+        return i;
+    }
+}
+
+static inline double
+TSP_func_double_abs(double x) {
+    CHECK_NAN(x);
+    if (x < 0) {
+        return x * -1.0;
+    } else {
+        return x;
+    }
+}
+
+#define TSP_func_acos(a)  _TSP_func_acos(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_acos(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = acos(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " acos()");
+    }
+    return z;
+}
+
+#define TSP_func_asin(a) _TSP_func_asin(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_asin(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = asin(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " asin()");
+    }
+    return z;
+}
+
+#define TSP_func_atan(a) _TSP_func_atan(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_atan(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = atan(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " atan()");
+    }
+    return z;
+}
+
+#define TSP_func_atan2(a,b) _TSP_func_atan2(rc, &exprErrMsg, (a), (b))
+static inline double
+_TSP_func_atan2(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = atan2(x, y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " atan2()");
+    }
+    return z;
+}
+
+#define TSP_func_ceil(a)  _TSP_func_ceil(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_ceil(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = ceil(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " ceil()");
+    }
+    return z;
+}
+
+#define TSP_func_cos(a) _TSP_func_cos(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_cos(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = cos(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " cos()");
+    }
+    return z;
+}
+
+#define TSP_func_cosh(a) _TSP_func_cosh(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_cosh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = cosh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " cosh()");
+    }
+    return z;
+}
+
+#define TSP_func_exp(a) _TSP_func_exp(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_exp(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = exp(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " exp()");
+    }
+    return z;
+}
+
+#define TSP_func_floor(a) _TSP_func_floor(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_floor(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = floor(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " floor()");
+    }
+    return z;
+}
+
+#define TSP_func_fmod(a) _TSP_func_fmod(rc, &exprErrMsg, (a), (b))
+static inline double
+_TSP_func_fmod(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = fmod(x, y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " fmod()");
+    }
+    return z;
+}
+
+#define TSP_func_hypot(a,b) _TSP_func_hypot(rc, &exprErrMsg, (a), (b))
+static inline double
+_TSP_func_hypot(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = hypot(x, y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " hypot()");
+    }
+    return z;
+}
+
+#define TSP_func_log(a) _TSP_func_log(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_log(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = log(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " log()");
+    }
+    return z;
+}
+
+#define TSP_func_log10(a) _TSP_func_log10(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_log10(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = log(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " log10()");
+    }
+    return z;
+}
+#ifndef max
+#define max(a,b) \
+   ({ __typeof__ (a) _a = (a); \
+       __typeof__ (b) _b = (b); \
+     _a > _b ? _a : _b; })
+#endif
+#define TSP_func_max(a,b)  _TSP_func_max(rc, &exprErrMsg, (a), (b))
+static inline double
+_TSP_func_max(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = max(x,y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " max()");
+    }
+    return z;
+}
+#ifndef min
+#define min(a,b) \
+   ({ __typeof__ (a) _a = (a); \
+       __typeof__ (b) _b = (b); \
+     _a <= _b ? _a : _b; })
+#endif
+#define TSP_func_min(a,b)  _TSP_func_min(rc, &exprErrMsg, (a), (b))
+static inline double
+_TSP_func_min(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = min(x,y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " min()");
+    }
+    return z;
+}
+
+#define TSP_func_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
+#define TSP_func_double_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
+static inline double
+_TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = pow(x, y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
+    }
+    return z;
+}
+
+#define TSP_func_int_pow(a,b) _TSP_func_double_int_pow(rc, &exprErrMsg, (a), (b))
+static inline double
+_TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
+    double z;
+    CHECK_NAN(x);
+    z = pow(x, (double) y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
+    }
+    return z;
+}
+
+
+static inline double
+TSP_func_rand() {
+    return rand(); 
+}
+
+static inline double
+TSP_func_round(double x) {
+    return round(x);
+}
+
+#define TSP_func_sin(a) _TSP_func_sin(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_sin(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sin(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sin()");
+    }
+    return z;
+}
+
+#define TSP_func_sinh(a) _TSP_func_sinh(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_sinh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sinh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sinh()");
+    }
+    return z;
+}
+
+#define TSP_func_sqrt(a) _TSP_func_sqrt(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sqrt(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sqrt()");
+    }
+    return z;
+}
+
+static inline double
+TSP_func_int_srand(Tcl_WideInt i) {
+    srand((long) i);
+    return rand();
+}
+
+#define TSP_func_tan(a) _TSP_func_tan(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_tan(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = tan(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " tan()");
+    }
+    return z;
+}
+
+#define TSP_func_tanh(a) _TSP_func_tanh(rc, &exprErrMsg, (a))
+static inline double
+_TSP_func_tanh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = tanh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " tanh()");
+    }
+    return z;
+}
+
+
+
diff --git a/native/clang/cvs/TSP_func.2022-07-01_16-24.c b/native/clang/cvs/TSP_func.2022-07-01_16-24.c
new file mode 100755
index 0000000..fc9366c
--- /dev/null
+++ b/native/clang/cvs/TSP_func.2022-07-01_16-24.c
@@ -0,0 +1,464 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+#ifndef _MATH_H
+#include <math.h>
+#endif
+#include <stdlib.h>
+
+#ifndef _LIBC_LIMITS_H_
+#include <limits.h>
+#endif
+
+
+#define TRUE 1
+#define FALSE 0
+#define TSP_DIV_BY_ZERO "divide by zero"
+#define TSP_DOMAIN_ERROR "domain error"
+
+/* only record the first error */
+#define RAISE_ERROR(m) *rc = TCL_ERROR; if (*exprErrMsg == NULL) *exprErrMsg = m; return 0
+
+#define CHECK_NAN(a) if (isnan(a)) return NAN
+
+/* functions that can raise errors have macros to add rc and exprErrMsg parameters */
+
+#define TSP_func_int_div(a,b) _TSP_func_int_div(rc, &exprErrMsg, (a), (b))
+TSP_REMOVABLE Tcl_WideInt
+_TSP_func_int_div(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
+    Tcl_WideInt quotient;
+
+    if (divisor == 0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " IntDiv()");
+    }
+    if (dividend == LLONG_MIN && divisor == -1) {
+        /* Avoid integer overflow on (Long.MIN_VALUE / -1) */
+        quotient = LLONG_MIN;
+    } else {
+        quotient = dividend / divisor;
+        /* Round down to a smaller negative number if  */
+        /* there is a remainder and the quotient is    */
+        /* negative or zero and the signs don't match. */
+        if (((quotient < 0) || ((quotient == 0) && (((dividend < 0) && (divisor > 0)) || ((dividend > 0)
+                    && (divisor < 0))))) && ((quotient * divisor) != dividend)) {
+            quotient -= 1;
+        }
+    }
+    return quotient;
+}
+
+
+#define TSP_func_int_mod(a,b) _TSP_func_int_mod(rc, &exprErrMsg, (a), (b))
+TSP_REMOVABLE Tcl_WideInt
+_TSP_func_int_mod(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
+    Tcl_WideInt remainder = 0;
+    int neg_divisor = 0;
+
+    if (divisor == 0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " IntMod()");
+    }
+
+    if (dividend == LLONG_MIN && divisor == -1) {
+        remainder = 0;
+    } else {
+        if (divisor < 0) {
+            divisor = -divisor;
+            dividend = -dividend;
+            neg_divisor = 1;
+        }
+        remainder = dividend % divisor;
+        if (remainder < 0
+                && !(neg_divisor && (dividend == LLONG_MIN))) {
+            remainder += divisor;
+        }
+    }
+    if ((neg_divisor && (remainder > 0))
+                || (!neg_divisor && (remainder < 0))) {
+        remainder = -remainder;
+    }
+    return remainder;
+}
+
+
+#define TSP_func_double_div(a,b) _TSP_func_double_div(rc, &exprErrMsg, (a), (b))
+TSP_REMOVABLE double
+_TSP_func_double_div(int* rc, char** exprErrMsg, double x, double y) {
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    if (y == 0.0) {
+        RAISE_ERROR(TSP_DIV_BY_ZERO " DoubleDiv()");
+    } else {
+        return x / y;
+    }
+}
+
+TSP_REMOVABLE int
+TSP_func_util_strcmp(Tcl_DString* s1, Tcl_DString* s2) {
+    int match;
+    int length1 = Tcl_DStringLength(s1);
+    int length2 = Tcl_DStringLength(s2);
+    length1 = Tcl_NumUtfChars(Tcl_DStringValue(s1), length1);
+    length2 = Tcl_NumUtfChars(Tcl_DStringValue(s2), length2);
+    match = Tcl_UtfNcmp(Tcl_DStringValue(s1), Tcl_DStringValue(s2), (length1 < length2) ? length1 : length2);
+    if (match == 0) {
+        return length1 - length2;
+    } else {
+        return match;
+    }
+}
+
+TSP_REMOVABLE int
+TSP_func_str_lt(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) < 0) ? TRUE : FALSE;
+}
+
+TSP_REMOVABLE int
+TSP_func_str_gt(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) > 0) ? TRUE : FALSE;
+}
+
+TSP_REMOVABLE int
+TSP_func_str_le(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) <= 0) ? TRUE : FALSE;
+}
+
+TSP_REMOVABLE int
+TSP_func_str_ge(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) >= 0) ? TRUE : FALSE;
+}
+
+TSP_REMOVABLE int
+TSP_func_str_eq(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) == 0) ? TRUE : FALSE;
+}
+
+TSP_REMOVABLE int
+TSP_func_str_ne(Tcl_DString* s1, Tcl_DString* s2) {
+    return (TSP_func_util_strcmp(s1, s2) != 0) ? TRUE : FALSE;
+}
+
+
+TSP_REMOVABLE Tcl_WideInt
+TSP_func_int_abs(Tcl_WideInt i) {
+    if (i < 0) {
+        if (i == LLONG_MIN) {
+            return 0;
+        } else {
+            return i * -1;
+        }
+    } else {
+        return i;
+    }
+}
+
+TSP_REMOVABLE double
+TSP_func_double_abs(double x) {
+    CHECK_NAN(x);
+    if (x < 0) {
+        return x * -1.0;
+    } else {
+        return x;
+    }
+}
+
+#define TSP_func_acos(a)  _TSP_func_acos(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_acos(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = acos(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " acos()");
+    }
+    return z;
+}
+
+#define TSP_func_asin(a) _TSP_func_asin(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_asin(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = asin(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " asin()");
+    }
+    return z;
+}
+
+#define TSP_func_atan(a) _TSP_func_atan(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_atan(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = atan(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " atan()");
+    }
+    return z;
+}
+
+#define TSP_func_atan2(a,b) _TSP_func_atan2(rc, &exprErrMsg, (a), (b))
+TSP_REMOVABLE double
+_TSP_func_atan2(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = atan2(x, y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " atan2()");
+    }
+    return z;
+}
+
+#define TSP_func_ceil(a)  _TSP_func_ceil(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_ceil(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = ceil(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " ceil()");
+    }
+    return z;
+}
+
+#define TSP_func_cos(a) _TSP_func_cos(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_cos(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = cos(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " cos()");
+    }
+    return z;
+}
+
+#define TSP_func_cosh(a) _TSP_func_cosh(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_cosh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = cosh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " cosh()");
+    }
+    return z;
+}
+
+#define TSP_func_exp(a) _TSP_func_exp(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_exp(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = exp(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " exp()");
+    }
+    return z;
+}
+
+#define TSP_func_floor(a) _TSP_func_floor(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_floor(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = floor(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " floor()");
+    }
+    return z;
+}
+
+#define TSP_func_fmod(a) _TSP_func_fmod(rc, &exprErrMsg, (a), (b))
+TSP_REMOVABLE double
+_TSP_func_fmod(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = fmod(x, y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " fmod()");
+    }
+    return z;
+}
+
+#define TSP_func_hypot(a,b) _TSP_func_hypot(rc, &exprErrMsg, (a), (b))
+TSP_REMOVABLE double
+_TSP_func_hypot(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = hypot(x, y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " hypot()");
+    }
+    return z;
+}
+
+#define TSP_func_log(a) _TSP_func_log(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_log(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = log(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " log()");
+    }
+    return z;
+}
+
+#define TSP_func_log10(a) _TSP_func_log10(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_log10(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = log(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " log10()");
+    }
+    return z;
+}
+#ifndef max
+#define max(a,b) \
+   ({ __typeof__ (a) _a = (a); \
+       __typeof__ (b) _b = (b); \
+     _a > _b ? _a : _b; })
+#endif
+#define TSP_func_max(a,b)  _TSP_func_max(rc, &exprErrMsg, (a), (b))
+TSP_REMOVABLE double
+_TSP_func_max(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = max(x,y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " max()");
+    }
+    return z;
+}
+#ifndef min
+#define min(a,b) \
+   ({ __typeof__ (a) _a = (a); \
+       __typeof__ (b) _b = (b); \
+     _a <= _b ? _a : _b; })
+#endif
+#define TSP_func_min(a,b)  _TSP_func_min(rc, &exprErrMsg, (a), (b))
+TSP_REMOVABLE double
+_TSP_func_min(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = min(x,y);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " min()");
+    }
+    return z;
+}
+
+#define TSP_func_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
+#define TSP_func_double_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
+TSP_REMOVABLE double
+_TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
+    double z;
+    CHECK_NAN(x);
+    CHECK_NAN(y);
+    z = pow(x, y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
+    }
+    return z;
+}
+
+#define TSP_func_int_pow(a,b) _TSP_func_double_int_pow(rc, &exprErrMsg, (a), (b))
+TSP_REMOVABLE double
+_TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
+    double z;
+    CHECK_NAN(x);
+    z = pow(x, (double) y);
+    if (isnan(z) || z == HUGE_VAL) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
+    }
+    return z;
+}
+
+
+TSP_REMOVABLE double
+TSP_func_rand() {
+    return rand(); 
+}
+
+TSP_REMOVABLE double
+TSP_func_round(double x) {
+    return round(x);
+}
+
+#define TSP_func_sin(a) _TSP_func_sin(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_sin(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sin(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sin()");
+    }
+    return z;
+}
+
+#define TSP_func_sinh(a) _TSP_func_sinh(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_sinh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sinh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sinh()");
+    }
+    return z;
+}
+
+#define TSP_func_sqrt(a) _TSP_func_sqrt(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = sqrt(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " sqrt()");
+    }
+    return z;
+}
+
+TSP_REMOVABLE double
+TSP_func_int_srand(Tcl_WideInt i) {
+    srand((long) i);
+    return rand();
+}
+
+#define TSP_func_tan(a) _TSP_func_tan(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_tan(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = tan(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " tan()");
+    }
+    return z;
+}
+
+#define TSP_func_tanh(a) _TSP_func_tanh(rc, &exprErrMsg, (a))
+TSP_REMOVABLE double
+_TSP_func_tanh(int* rc, char** exprErrMsg, double x) {
+    double z;
+    CHECK_NAN(x);
+    z = tanh(x);
+    if (isnan(z)) {
+        RAISE_ERROR(TSP_DOMAIN_ERROR " tanh()");
+    }
+    return z;
+}
+
+
+
diff --git a/native/clang/cvs/TSP_util.2015-07-28_21-19.c b/native/clang/cvs/TSP_util.2015-07-28_21-19.c
new file mode 100755
index 0000000..3d81eda
--- /dev/null
+++ b/native/clang/cvs/TSP_util.2015-07-28_21-19.c
@@ -0,0 +1,304 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+
+/*********************************************************************************************/
+/* convert to an int from a string */
+int
+TSP_Util_lang_convert_int_string(Tcl_Interp* interp, Tcl_DString* sourceVarName, Tcl_WideInt* targetVarName) {
+    int rc;
+    Tcl_Obj* obj = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
+    Tcl_IncrRefCount(obj);
+    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
+    Tcl_DecrRefCount(obj);
+    return rc;
+}
+
+
+/*********************************************************************************************/
+/* convert to an int from a string const */
+int
+TSP_Util_lang_convert_int_string_const(Tcl_Interp* interp, char* sourceVarName, Tcl_WideInt* targetVarName) {
+    int rc;
+    Tcl_Obj* obj = Tcl_NewStringObj(sourceVarName, -1);
+    Tcl_IncrRefCount(obj);
+    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
+    Tcl_DecrRefCount(obj);
+    return rc;
+}
+
+
+/*********************************************************************************************/
+/* convert to a string from an int */
+Tcl_DString*
+TSP_Util_lang_convert_string_int(Tcl_Interp* interp, Tcl_DString* targetVarName, Tcl_WideInt sourceVarName) {
+    char str[500];
+    char *format = "%" TCL_LL_MODIFIER "d";
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    sprintf(str, format, sourceVarName);
+    Tcl_DStringAppend(targetVarName, str, -1);
+    return targetVarName;
+}
+
+
+
+/*********************************************************************************************/
+/* convert to a string from a double */
+Tcl_DString*
+TSP_Util_lang_convert_string_double(Tcl_Interp* interp, Tcl_DString* targetVarName, double sourceVarName) {
+    char str[500];
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    Tcl_PrintDouble(interp, sourceVarName, str);
+    Tcl_DStringAppend(targetVarName, str, -1);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* convert to a string from a var */
+Tcl_DString*
+TSP_Util_lang_convert_string_var(Tcl_DString* targetVarName, Tcl_Obj* sourceVarName) {
+    char* str;
+    int len;
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    str = Tcl_GetStringFromObj(sourceVarName, &len);
+    Tcl_DStringAppend(targetVarName, str, len);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* get a string from an int */
+/* string must be used immediately */
+Tcl_DString*
+TSP_Util_lang_get_string_int(Tcl_WideInt sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    Tcl_DString* dsPtr;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    dsPtr = &ds;
+    dsPtr = TSP_Util_lang_convert_string_int(NULL, dsPtr, sourceVarName);
+    return dsPtr;
+}
+
+
+/*********************************************************************************************/
+/* get a string from an double */
+/* string must be used immediately */
+Tcl_DString*
+TSP_Util_lang_get_string_double(double sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    TSP_Util_lang_convert_string_double(NULL, &ds, sourceVarName);
+    return &ds;
+}
+
+/*********************************************************************************************/
+/* get a string from a var */
+/* string must be used immediately */
+Tcl_DString*
+TSP_Util_lang_get_string_var(Tcl_Obj* sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    int len;
+    char* str;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    str = Tcl_GetStringFromObj(sourceVarName, &len);
+    Tcl_DStringAppend(&ds, str, len);
+    return &ds;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from a boolean */
+Tcl_Obj*
+TSP_Util_lang_assign_var_boolean(Tcl_Obj* targetVarName, int sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewBooleanObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an int */
+Tcl_Obj*
+TSP_Util_lang_assign_var_int(Tcl_Obj* targetVarName, Tcl_WideInt sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewWideIntObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an double */
+Tcl_Obj*
+TSP_Util_lang_assign_var_double(Tcl_Obj* targetVarName, double sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewDoubleObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an string */
+Tcl_Obj*
+TSP_Util_lang_assign_var_string(Tcl_Obj* targetVarName, Tcl_DString* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an string const */
+Tcl_Obj*
+TSP_Util_lang_assign_var_string_const(Tcl_Obj* targetVarName, char* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewStringObj(sourceVarName, -1);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from a var */
+Tcl_Obj*
+TSP_Util_lang_assign_var_var(Tcl_Obj* targetVarName, Tcl_Obj* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+
+    /* targetVarName = Tcl_DuplicateObj(sourceVarName);  */
+    targetVarName = sourceVarName;
+
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign an array & element from a var */
+int
+TSP_Util_lang_assign_array_var(Tcl_Interp* interp, Tcl_Obj* targetArrayVar, Tcl_Obj* targetIdxVar, Tcl_Obj* var) {
+    Tcl_Obj* obj;
+    obj = Tcl_ObjSetVar2(interp, targetArrayVar, targetIdxVar, var, TCL_LEAVE_ERR_MSG);
+    if (obj == NULL) {
+        return TCL_ERROR;
+    } else {
+        return TCL_OK;
+    }
+}
+
+
+/*********************************************************************************************/
+/* compare two Tcl_DStrings */
+int
+TSP_Util_string_compare(Tcl_DString* s1, Tcl_DString* s2) {
+    char* string2;
+    int length2;
+
+    return TSP_Util_string_compare_const(s1, Tcl_DStringValue(s2), Tcl_DStringLength(s2));
+}
+
+/*********************************************************************************************/
+/* compare a Tcl_DString to a const string. use negative length to find first null in string2 */
+int
+TSP_Util_string_compare_const(Tcl_DString* s1, char* string2, int length2) {
+    char* string1;
+    int length1;
+    int length;
+    int match;
+
+    string1 = Tcl_DStringValue(s1);
+    length1 = Tcl_DStringLength(s1);
+
+    length1 = Tcl_NumUtfChars(string1, length1);
+    length2 = Tcl_NumUtfChars(string2, length2);
+    
+    length = (length1 < length2) ? length1 : length2;
+    match = Tcl_UtfNcmp(string1, string2, (unsigned) length);
+    if (match == 0) {
+        match = length1 - length2;
+    }
+    return match;
+}
+
+
+/*********************************************************************************************/
+/* create a constant string obj                                                              */
+Tcl_Obj*
+TSP_Util_const_string(char* str) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewStringObj(str, -1);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+/*********************************************************************************************/
+/* create a constant wide int obj                                                            */
+Tcl_Obj*
+TSP_Util_const_int(Tcl_WideInt i) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewWideIntObj(i);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+/*********************************************************************************************/
+/* create a constant double obj                                                              */
+Tcl_Obj*
+TSP_Util_const_double(double d) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewDoubleObj(d);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+
+
diff --git a/native/clang/cvs/TSP_util.2022-04-24_23-21.c b/native/clang/cvs/TSP_util.2022-04-24_23-21.c
new file mode 100755
index 0000000..6f910f7
--- /dev/null
+++ b/native/clang/cvs/TSP_util.2022-04-24_23-21.c
@@ -0,0 +1,304 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+
+/*********************************************************************************************/
+/* convert to an int from a string */
+int
+TSP_Util_lang_convert_int_string(Tcl_Interp* interp, Tcl_DString* sourceVarName, Tcl_WideInt* targetVarName) {
+    int rc;
+    Tcl_Obj* obj = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
+    Tcl_IncrRefCount(obj);
+    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
+    Tcl_DecrRefCount(obj);
+    return rc;
+}
+
+
+/*********************************************************************************************/
+/* convert to an int from a string const */
+int
+TSP_Util_lang_convert_int_string_const(Tcl_Interp* interp, char* sourceVarName, Tcl_WideInt* targetVarName) {
+    int rc;
+    Tcl_Obj* obj = Tcl_NewStringObj(sourceVarName, -1);
+    Tcl_IncrRefCount(obj);
+    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
+    Tcl_DecrRefCount(obj);
+    return rc;
+}
+
+
+/*********************************************************************************************/
+/* convert to a string from an int */
+Tcl_DString*
+TSP_Util_lang_convert_string_int(Tcl_Interp* interp, Tcl_DString* targetVarName, Tcl_WideInt sourceVarName) {
+    char str[500];
+    char *format = "%" TCL_LL_MODIFIER "d";
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    sprintf(str, format, sourceVarName);
+    Tcl_DStringAppend(targetVarName, str, -1);
+    return targetVarName;
+}
+
+
+
+/*********************************************************************************************/
+/* convert to a string from a double */
+Tcl_DString*
+TSP_Util_lang_convert_string_double(Tcl_Interp* interp, Tcl_DString* targetVarName, double sourceVarName) {
+    char str[500];
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    Tcl_PrintDouble(interp, sourceVarName, str);
+    Tcl_DStringAppend(targetVarName, str, -1);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* convert to a string from a var */
+Tcl_DString*
+TSP_Util_lang_convert_string_var(Tcl_DString* targetVarName, Tcl_Obj* sourceVarName) {
+    char* str;
+    int len;
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    str = Tcl_GetStringFromObj(sourceVarName, &len);
+    Tcl_DStringAppend(targetVarName, str, len);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* get a string from an int */
+/* string must be used immediately */
+Tcl_DString*
+TSP_Util_lang_get_string_int(Tcl_WideInt sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    Tcl_DString* dsPtr;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    dsPtr = &ds;
+    dsPtr = TSP_Util_lang_convert_string_int(NULL, dsPtr, sourceVarName);
+    return dsPtr;
+}
+
+
+/*********************************************************************************************/
+/* get a string from an double */
+/* string must be used immediately */
+Tcl_DString*
+TSP_Util_lang_get_string_double(double sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    TSP_Util_lang_convert_string_double(NULL, &ds, sourceVarName);
+    return &ds;
+}
+
+/*********************************************************************************************/
+/* get a string from a var */
+/* string must be used immediately */
+Tcl_DString*
+TSP_Util_lang_get_string_var(Tcl_Obj* sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    int len;
+    char* str;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    str = Tcl_GetStringFromObj(sourceVarName, &len);
+    Tcl_DStringAppend(&ds, str, len);
+    return &ds;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from a boolean */
+Tcl_Obj*
+TSP_Util_lang_assign_var_boolean(Tcl_Obj* targetVarName, int sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewBooleanObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an int */
+Tcl_Obj*
+TSP_Util_lang_assign_var_int(Tcl_Obj* targetVarName, Tcl_WideInt sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewWideIntObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an double */
+Tcl_Obj*
+TSP_Util_lang_assign_var_double(Tcl_Obj* targetVarName, double sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewDoubleObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an string */
+Tcl_Obj*
+TSP_Util_lang_assign_var_string(Tcl_Obj* targetVarName, Tcl_DString* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an string const */
+Tcl_Obj*
+TSP_Util_lang_assign_var_string_const(Tcl_Obj* targetVarName, char* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewStringObj(sourceVarName, -1);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from a var */
+Tcl_Obj*
+TSP_Util_lang_assign_var_var(Tcl_Obj* targetVarName, Tcl_Obj* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+
+     targetVarName = Tcl_DuplicateObj(sourceVarName);  
+    //targetVarName = sourceVarName;
+
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign an array & element from a var */
+int
+TSP_Util_lang_assign_array_var(Tcl_Interp* interp, Tcl_Obj* targetArrayVar, Tcl_Obj* targetIdxVar, Tcl_Obj* var) {
+    Tcl_Obj* obj;
+    obj = Tcl_ObjSetVar2(interp, targetArrayVar, targetIdxVar, var, TCL_LEAVE_ERR_MSG);
+    if (obj == NULL) {
+        return TCL_ERROR;
+    } else {
+        return TCL_OK;
+    }
+}
+
+/*********************************************************************************************/
+/* compare a Tcl_DString to a const string. use negative length to find first null in string2 */
+int
+TSP_Util_string_compare_const(Tcl_DString* s1, char* string2, int length2) {
+    char* string1;
+    int length1;
+    int length;
+    int match;
+
+    string1 = Tcl_DStringValue(s1);
+    length1 = Tcl_DStringLength(s1);
+
+    length1 = Tcl_NumUtfChars(string1, length1);
+    length2 = Tcl_NumUtfChars(string2, length2);
+    
+    length = (length1 < length2) ? length1 : length2;
+    match = Tcl_UtfNcmp(string1, string2, (unsigned) length);
+    if (match == 0) {
+        match = length1 - length2;
+    }
+    return match;
+}
+
+
+/*********************************************************************************************/
+/* compare two Tcl_DStrings */
+int
+TSP_Util_string_compare(Tcl_DString* s1, Tcl_DString* s2) {
+    char* string2;
+    int length2;
+
+    return TSP_Util_string_compare_const(s1, Tcl_DStringValue(s2), Tcl_DStringLength(s2));
+}
+
+
+/*********************************************************************************************/
+/* create a constant string obj                                                              */
+Tcl_Obj*
+TSP_Util_const_string(char* str) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewStringObj(str, -1);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+/*********************************************************************************************/
+/* create a constant wide int obj                                                            */
+Tcl_Obj*
+TSP_Util_const_int(Tcl_WideInt i) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewWideIntObj(i);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+/*********************************************************************************************/
+/* create a constant double obj                                                              */
+Tcl_Obj*
+TSP_Util_const_double(double d) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewDoubleObj(d);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+
+
diff --git a/native/clang/cvs/TSP_util.2022-05-13_12-25.c b/native/clang/cvs/TSP_util.2022-05-13_12-25.c
new file mode 100755
index 0000000..15c16f9
--- /dev/null
+++ b/native/clang/cvs/TSP_util.2022-05-13_12-25.c
@@ -0,0 +1,313 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+
+/*********************************************************************************************/
+/* convert to an int from a string */
+int
+TSP_Util_lang_convert_int_string(Tcl_Interp* interp, Tcl_DString* sourceVarName, Tcl_WideInt* targetVarName) {
+    int rc;
+    Tcl_Obj* obj = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
+    Tcl_IncrRefCount(obj);
+    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
+    Tcl_DecrRefCount(obj);
+    return rc;
+}
+
+
+/*********************************************************************************************/
+/* convert to an int from a string const */
+int
+TSP_Util_lang_convert_int_string_const(Tcl_Interp* interp, char* sourceVarName, Tcl_WideInt* targetVarName) {
+    int rc;
+    Tcl_Obj* obj = Tcl_NewStringObj(sourceVarName, -1);
+    Tcl_IncrRefCount(obj);
+    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
+    Tcl_DecrRefCount(obj);
+    return rc;
+}
+
+
+/*********************************************************************************************/
+/* convert to a string from an int */
+Tcl_DString*
+TSP_Util_lang_convert_string_int(Tcl_Interp* interp, Tcl_DString* targetVarName, Tcl_WideInt sourceVarName) {
+    char str[500];
+    char *format = "%" TCL_LL_MODIFIER "d";
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    sprintf(str, format, sourceVarName);
+    Tcl_DStringAppend(targetVarName, str, -1);
+    return targetVarName;
+}
+
+
+
+/*********************************************************************************************/
+/* convert to a string from a double */
+Tcl_DString*
+TSP_Util_lang_convert_string_double(Tcl_Interp* interp, Tcl_DString* targetVarName, double sourceVarName) {
+    char str[500];
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    Tcl_PrintDouble(interp, sourceVarName, str);
+    Tcl_DStringAppend(targetVarName, str, -1);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* convert to a string from a var */
+Tcl_DString*
+TSP_Util_lang_convert_string_var(Tcl_DString* targetVarName, Tcl_Obj* sourceVarName) {
+    char* str;
+    int len;
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    str = Tcl_GetStringFromObj(sourceVarName, &len);
+    Tcl_DStringAppend(targetVarName, str, len);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* get a string from an int */
+/* string must be used immediately */
+Tcl_DString*
+TSP_Util_lang_get_string_int(Tcl_WideInt sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    Tcl_DString* dsPtr;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    dsPtr = &ds;
+    dsPtr = TSP_Util_lang_convert_string_int(NULL, dsPtr, sourceVarName);
+    return dsPtr;
+}
+
+
+/*********************************************************************************************/
+/* get a string from an double */
+/* string must be used immediately */
+Tcl_DString*
+TSP_Util_lang_get_string_double(double sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    TSP_Util_lang_convert_string_double(NULL, &ds, sourceVarName);
+    return &ds;
+}
+
+/*********************************************************************************************/
+/* get a string from a var */
+/* string must be used immediately */
+Tcl_DString*
+TSP_Util_lang_get_string_var(Tcl_Obj* sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    int len;
+    char* str;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    str = Tcl_GetStringFromObj(sourceVarName, &len);
+    Tcl_DStringAppend(&ds, str, len);
+    return &ds;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from a boolean */
+Tcl_Obj*
+TSP_Util_lang_assign_var_boolean(Tcl_Obj* targetVarName, int sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewBooleanObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an int */
+Tcl_Obj*
+TSP_Util_lang_assign_var_int(Tcl_Obj* targetVarName, Tcl_WideInt sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewWideIntObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an double */
+Tcl_Obj*
+TSP_Util_lang_assign_var_double(Tcl_Obj* targetVarName, double sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewDoubleObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an string */
+Tcl_Obj*
+TSP_Util_lang_assign_var_string(Tcl_Obj* targetVarName, Tcl_DString* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an string const */
+Tcl_Obj*
+TSP_Util_lang_assign_var_string_const(Tcl_Obj* targetVarName, char* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewStringObj(sourceVarName, -1);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from a var */
+Tcl_Obj*
+TSP_Util_lang_assign_var_var(Tcl_Obj* targetVarName, Tcl_Obj* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+
+     targetVarName = Tcl_DuplicateObj(sourceVarName);  
+    //targetVarName = sourceVarName;
+
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign an array & element from a var */
+int
+TSP_Util_lang_assign_array_var(Tcl_Interp* interp, Tcl_Obj* targetArrayVar, Tcl_Obj* targetIdxVar, Tcl_Obj* var) {
+    Tcl_Obj* obj;
+    obj = Tcl_ObjSetVar2(interp, targetArrayVar, targetIdxVar, var, TCL_LEAVE_ERR_MSG);
+    if (obj == NULL) {
+        return TCL_ERROR;
+    } else {
+        return TCL_OK;
+    }
+}
+
+/*********************************************************************************************/
+/* compare a Tcl_DString to a const string. use negative length to find first null in string2 */
+int
+TSP_Util_string_compare_const(Tcl_DString* s1, char* string2, int length2) {
+    char* string1;
+    int length1;
+    int length;
+    int match;
+
+    string1 = Tcl_DStringValue(s1);
+    length1 = Tcl_DStringLength(s1);
+
+    length1 = Tcl_NumUtfChars(string1, length1);
+    length2 = Tcl_NumUtfChars(string2, length2);
+    
+    length = (length1 < length2) ? length1 : length2;
+    match = Tcl_UtfNcmp(string1, string2, (unsigned) length);
+    if (match == 0) {
+        match = length1 - length2;
+    }
+    return match;
+}
+
+
+/*********************************************************************************************/
+/* compare two Tcl_DStrings */
+int
+TSP_Util_string_compare(Tcl_DString* s1, Tcl_DString* s2) {
+    char* string2;
+    int length2;
+
+    return TSP_Util_string_compare_const(s1, Tcl_DStringValue(s2), Tcl_DStringLength(s2));
+}
+
+
+/* create Dstring from Char in tmpVar */ 
+Tcl_DString* TSP_UTIL_dstring_from_char (char* str, Tcl_DString* tmpvar) {
+    Tcl_DStringSetLength(tmpvar, 0);
+    Tcl_DStringAppend(tmpvar, str, -1);
+    return tmpvar;
+}
+
+
+
+/*********************************************************************************************/
+/* create a constant string obj                                                              */
+Tcl_Obj*
+TSP_Util_const_string(char* str) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewStringObj(str, -1);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+/*********************************************************************************************/
+/* create a constant wide int obj                                                            */
+Tcl_Obj*
+TSP_Util_const_int(Tcl_WideInt i) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewWideIntObj(i);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+/*********************************************************************************************/
+/* create a constant double obj                                                              */
+Tcl_Obj*
+TSP_Util_const_double(double d) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewDoubleObj(d);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+
+
diff --git a/native/clang/cvs/TSP_util.2022-07-01_14-55.c b/native/clang/cvs/TSP_util.2022-07-01_14-55.c
new file mode 100755
index 0000000..2d440cf
--- /dev/null
+++ b/native/clang/cvs/TSP_util.2022-07-01_14-55.c
@@ -0,0 +1,313 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+
+/*********************************************************************************************/
+/* convert to an int from a string */
+static inline int
+TSP_Util_lang_convert_int_string(Tcl_Interp* interp, Tcl_DString* sourceVarName, Tcl_WideInt* targetVarName) {
+    int rc;
+    Tcl_Obj* obj = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
+    Tcl_IncrRefCount(obj);
+    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
+    Tcl_DecrRefCount(obj);
+    return rc;
+}
+
+
+/*********************************************************************************************/
+/* convert to an int from a string const */
+static inline int
+TSP_Util_lang_convert_int_string_const(Tcl_Interp* interp, char* sourceVarName, Tcl_WideInt* targetVarName) {
+    int rc;
+    Tcl_Obj* obj = Tcl_NewStringObj(sourceVarName, -1);
+    Tcl_IncrRefCount(obj);
+    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
+    Tcl_DecrRefCount(obj);
+    return rc;
+}
+
+
+/*********************************************************************************************/
+/* convert to a string from an int */
+static inline Tcl_DString*
+TSP_Util_lang_convert_string_int(Tcl_Interp* interp, Tcl_DString* targetVarName, Tcl_WideInt sourceVarName) {
+    char str[500];
+    char *format = "%" TCL_LL_MODIFIER "d";
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    sprintf(str, format, sourceVarName);
+    Tcl_DStringAppend(targetVarName, str, -1);
+    return targetVarName;
+}
+
+
+
+/*********************************************************************************************/
+/* convert to a string from a double */
+static inline Tcl_DString*
+TSP_Util_lang_convert_string_double(Tcl_Interp* interp, Tcl_DString* targetVarName, double sourceVarName) {
+    char str[500];
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    Tcl_PrintDouble(interp, sourceVarName, str);
+    Tcl_DStringAppend(targetVarName, str, -1);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* convert to a string from a var */
+static inline Tcl_DString*
+TSP_Util_lang_convert_string_var(Tcl_DString* targetVarName, Tcl_Obj* sourceVarName) {
+    char* str;
+    int len;
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    str = Tcl_GetStringFromObj(sourceVarName, &len);
+    Tcl_DStringAppend(targetVarName, str, len);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* get a string from an int */
+/* string must be used immediately */
+static inline Tcl_DString*
+TSP_Util_lang_get_string_int(Tcl_WideInt sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    Tcl_DString* dsPtr;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    dsPtr = &ds;
+    dsPtr = TSP_Util_lang_convert_string_int(NULL, dsPtr, sourceVarName);
+    return dsPtr;
+}
+
+
+/*********************************************************************************************/
+/* get a string from an double */
+/* string must be used immediately */
+static inline Tcl_DString*
+TSP_Util_lang_get_string_double(double sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    TSP_Util_lang_convert_string_double(NULL, &ds, sourceVarName);
+    return &ds;
+}
+
+/*********************************************************************************************/
+/* get a string from a var */
+/* string must be used immediately */
+static inline Tcl_DString*
+TSP_Util_lang_get_string_var(Tcl_Obj* sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    int len;
+    char* str;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    str = Tcl_GetStringFromObj(sourceVarName, &len);
+    Tcl_DStringAppend(&ds, str, len);
+    return &ds;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from a boolean */
+static inline Tcl_Obj*
+TSP_Util_lang_assign_var_boolean(Tcl_Obj* targetVarName, int sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewBooleanObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an int */
+static inline Tcl_Obj*
+TSP_Util_lang_assign_var_int(Tcl_Obj* targetVarName, Tcl_WideInt sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewWideIntObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an double */
+static inline Tcl_Obj*
+TSP_Util_lang_assign_var_double(Tcl_Obj* targetVarName, double sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewDoubleObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an string */
+static inline Tcl_Obj*
+TSP_Util_lang_assign_var_string(Tcl_Obj* targetVarName, Tcl_DString* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an string const */
+static inline Tcl_Obj*
+TSP_Util_lang_assign_var_string_const(Tcl_Obj* targetVarName, char* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewStringObj(sourceVarName, -1);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from a var */
+static inline Tcl_Obj*
+TSP_Util_lang_assign_var_var(Tcl_Obj* targetVarName, Tcl_Obj* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+
+     targetVarName = Tcl_DuplicateObj(sourceVarName);  
+    //targetVarName = sourceVarName;
+
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign an array & element from a var */
+static inline int
+TSP_Util_lang_assign_array_var(Tcl_Interp* interp, Tcl_Obj* targetArrayVar, Tcl_Obj* targetIdxVar, Tcl_Obj* var) {
+    Tcl_Obj* obj;
+    obj = Tcl_ObjSetVar2(interp, targetArrayVar, targetIdxVar, var, TCL_LEAVE_ERR_MSG);
+    if (obj == NULL) {
+        return TCL_ERROR;
+    } else {
+        return TCL_OK;
+    }
+}
+
+/*********************************************************************************************/
+/* compare a Tcl_DString to a const string. use negative length to find first null in string2 */
+static inline int
+TSP_Util_string_compare_const(Tcl_DString* s1, char* string2, int length2) {
+    char* string1;
+    int length1;
+    int length;
+    int match;
+
+    string1 = Tcl_DStringValue(s1);
+    length1 = Tcl_DStringLength(s1);
+
+    length1 = Tcl_NumUtfChars(string1, length1);
+    length2 = Tcl_NumUtfChars(string2, length2);
+    
+    length = (length1 < length2) ? length1 : length2;
+    match = Tcl_UtfNcmp(string1, string2, (unsigned) length);
+    if (match == 0) {
+        match = length1 - length2;
+    }
+    return match;
+}
+
+
+/*********************************************************************************************/
+/* compare two Tcl_DStrings */
+static inline int
+TSP_Util_string_compare(Tcl_DString* s1, Tcl_DString* s2) {
+    char* string2;
+    int length2;
+
+    return TSP_Util_string_compare_const(s1, Tcl_DStringValue(s2), Tcl_DStringLength(s2));
+}
+
+
+/* create Dstring from Char in tmpVar */ 
+Tcl_DString* TSP_UTIL_dstring_from_char (char* str, Tcl_DString* tmpvar) {
+    Tcl_DStringSetLength(tmpvar, 0);
+    Tcl_DStringAppend(tmpvar, str, -1);
+    return tmpvar;
+}
+
+
+
+/*********************************************************************************************/
+/* create a constant string obj                                                              */
+static inline Tcl_Obj*
+TSP_Util_const_string(char* str) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewStringObj(str, -1);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+/*********************************************************************************************/
+/* create a constant wide int obj                                                            */
+static inline Tcl_Obj*
+TSP_Util_const_int(Tcl_WideInt i) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewWideIntObj(i);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+/*********************************************************************************************/
+/* create a constant double obj                                                              */
+static inline Tcl_Obj*
+TSP_Util_const_double(double d) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewDoubleObj(d);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+
+
diff --git a/native/clang/cvs/TSP_util.2022-07-01_16-24.c b/native/clang/cvs/TSP_util.2022-07-01_16-24.c
new file mode 100755
index 0000000..a17879f
--- /dev/null
+++ b/native/clang/cvs/TSP_util.2022-07-01_16-24.c
@@ -0,0 +1,313 @@
+#ifndef _TCL
+#include <tcl.h>
+#endif
+
+
+/*********************************************************************************************/
+/* convert to an int from a string */
+TSP_REMOVABLE int
+TSP_Util_lang_convert_int_string(Tcl_Interp* interp, Tcl_DString* sourceVarName, Tcl_WideInt* targetVarName) {
+    int rc;
+    Tcl_Obj* obj = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
+    Tcl_IncrRefCount(obj);
+    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
+    Tcl_DecrRefCount(obj);
+    return rc;
+}
+
+
+/*********************************************************************************************/
+/* convert to an int from a string const */
+TSP_REMOVABLE int
+TSP_Util_lang_convert_int_string_const(Tcl_Interp* interp, char* sourceVarName, Tcl_WideInt* targetVarName) {
+    int rc;
+    Tcl_Obj* obj = Tcl_NewStringObj(sourceVarName, -1);
+    Tcl_IncrRefCount(obj);
+    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
+    Tcl_DecrRefCount(obj);
+    return rc;
+}
+
+
+/*********************************************************************************************/
+/* convert to a string from an int */
+TSP_REMOVABLE Tcl_DString*
+TSP_Util_lang_convert_string_int(Tcl_Interp* interp, Tcl_DString* targetVarName, Tcl_WideInt sourceVarName) {
+    char str[500];
+    char *format = "%" TCL_LL_MODIFIER "d";
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    sprintf(str, format, sourceVarName);
+    Tcl_DStringAppend(targetVarName, str, -1);
+    return targetVarName;
+}
+
+
+
+/*********************************************************************************************/
+/* convert to a string from a double */
+TSP_REMOVABLE Tcl_DString*
+TSP_Util_lang_convert_string_double(Tcl_Interp* interp, Tcl_DString* targetVarName, double sourceVarName) {
+    char str[500];
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    Tcl_PrintDouble(interp, sourceVarName, str);
+    Tcl_DStringAppend(targetVarName, str, -1);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* convert to a string from a var */
+TSP_REMOVABLE Tcl_DString*
+TSP_Util_lang_convert_string_var(Tcl_DString* targetVarName, Tcl_Obj* sourceVarName) {
+    char* str;
+    int len;
+    if (targetVarName != NULL) {
+        Tcl_DStringSetLength(targetVarName, 0);
+    } else {
+        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
+        Tcl_DStringInit(targetVarName);
+    }
+    str = Tcl_GetStringFromObj(sourceVarName, &len);
+    Tcl_DStringAppend(targetVarName, str, len);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* get a string from an int */
+/* string must be used immediately */
+TSP_REMOVABLE Tcl_DString*
+TSP_Util_lang_get_string_int(Tcl_WideInt sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    Tcl_DString* dsPtr;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    dsPtr = &ds;
+    dsPtr = TSP_Util_lang_convert_string_int(NULL, dsPtr, sourceVarName);
+    return dsPtr;
+}
+
+
+/*********************************************************************************************/
+/* get a string from an double */
+/* string must be used immediately */
+TSP_REMOVABLE Tcl_DString*
+TSP_Util_lang_get_string_double(double sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    TSP_Util_lang_convert_string_double(NULL, &ds, sourceVarName);
+    return &ds;
+}
+
+/*********************************************************************************************/
+/* get a string from a var */
+/* string must be used immediately */
+TSP_REMOVABLE Tcl_DString*
+TSP_Util_lang_get_string_var(Tcl_Obj* sourceVarName) {
+    static int doInit = 1;
+    static Tcl_DString ds;
+    int len;
+    char* str;
+    if (doInit) {
+        Tcl_DStringInit(&ds);
+        doInit = 0;
+    } else {
+        Tcl_DStringSetLength(&ds, 0);
+    }
+    str = Tcl_GetStringFromObj(sourceVarName, &len);
+    Tcl_DStringAppend(&ds, str, len);
+    return &ds;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from a boolean */
+TSP_REMOVABLE Tcl_Obj*
+TSP_Util_lang_assign_var_boolean(Tcl_Obj* targetVarName, int sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewBooleanObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an int */
+TSP_REMOVABLE Tcl_Obj*
+TSP_Util_lang_assign_var_int(Tcl_Obj* targetVarName, Tcl_WideInt sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewWideIntObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an double */
+TSP_REMOVABLE Tcl_Obj*
+TSP_Util_lang_assign_var_double(Tcl_Obj* targetVarName, double sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewDoubleObj(sourceVarName);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an string */
+TSP_REMOVABLE Tcl_Obj*
+TSP_Util_lang_assign_var_string(Tcl_Obj* targetVarName, Tcl_DString* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from an string const */
+TSP_REMOVABLE Tcl_Obj*
+TSP_Util_lang_assign_var_string_const(Tcl_Obj* targetVarName, char* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+    targetVarName = Tcl_NewStringObj(sourceVarName, -1);
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign a var from a var */
+TSP_REMOVABLE Tcl_Obj*
+TSP_Util_lang_assign_var_var(Tcl_Obj* targetVarName, Tcl_Obj* sourceVarName) {
+    if (targetVarName != NULL) {
+        Tcl_DecrRefCount(targetVarName);
+    }
+
+     targetVarName = Tcl_DuplicateObj(sourceVarName);  
+    //targetVarName = sourceVarName;
+
+    Tcl_IncrRefCount(targetVarName);
+    return targetVarName;
+}
+
+
+/*********************************************************************************************/
+/* assign an array & element from a var */
+TSP_REMOVABLE int
+TSP_Util_lang_assign_array_var(Tcl_Interp* interp, Tcl_Obj* targetArrayVar, Tcl_Obj* targetIdxVar, Tcl_Obj* var) {
+    Tcl_Obj* obj;
+    obj = Tcl_ObjSetVar2(interp, targetArrayVar, targetIdxVar, var, TCL_LEAVE_ERR_MSG);
+    if (obj == NULL) {
+        return TCL_ERROR;
+    } else {
+        return TCL_OK;
+    }
+}
+
+/*********************************************************************************************/
+/* compare a Tcl_DString to a const string. use negative length to find first null in string2 */
+TSP_REMOVABLE int
+TSP_Util_string_compare_const(Tcl_DString* s1, char* string2, int length2) {
+    char* string1;
+    int length1;
+    int length;
+    int match;
+
+    string1 = Tcl_DStringValue(s1);
+    length1 = Tcl_DStringLength(s1);
+
+    length1 = Tcl_NumUtfChars(string1, length1);
+    length2 = Tcl_NumUtfChars(string2, length2);
+    
+    length = (length1 < length2) ? length1 : length2;
+    match = Tcl_UtfNcmp(string1, string2, (unsigned) length);
+    if (match == 0) {
+        match = length1 - length2;
+    }
+    return match;
+}
+
+
+/*********************************************************************************************/
+/* compare two Tcl_DStrings */
+TSP_REMOVABLE int
+TSP_Util_string_compare(Tcl_DString* s1, Tcl_DString* s2) {
+    char* string2;
+    int length2;
+
+    return TSP_Util_string_compare_const(s1, Tcl_DStringValue(s2), Tcl_DStringLength(s2));
+}
+
+
+/* create Dstring from Char in tmpVar */ 
+Tcl_DString* TSP_UTIL_dstring_from_char (char* str, Tcl_DString* tmpvar) {
+    Tcl_DStringSetLength(tmpvar, 0);
+    Tcl_DStringAppend(tmpvar, str, -1);
+    return tmpvar;
+}
+
+
+
+/*********************************************************************************************/
+/* create a constant string obj                                                              */
+TSP_REMOVABLE Tcl_Obj*
+TSP_Util_const_string(char* str) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewStringObj(str, -1);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+/*********************************************************************************************/
+/* create a constant wide int obj                                                            */
+TSP_REMOVABLE Tcl_Obj*
+TSP_Util_const_int(Tcl_WideInt i) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewWideIntObj(i);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+/*********************************************************************************************/
+/* create a constant double obj                                                              */
+TSP_REMOVABLE Tcl_Obj*
+TSP_Util_const_double(double d) {
+    Tcl_Obj* constObj;
+    constObj = Tcl_NewDoubleObj(d);
+    Tcl_IncrRefCount(constObj);
+    return constObj;
+}
+
+
+
diff --git a/native/clang/cvs/backup_n.2021-07-30_16-32.tcl b/native/clang/cvs/backup_n.2021-07-30_16-32.tcl
new file mode 100755
index 0000000..82fed8a
--- /dev/null
+++ b/native/clang/cvs/backup_n.2021-07-30_16-32.tcl
@@ -0,0 +1,23 @@
+#!/usr/bin/tclsh
+## exec tclkit
+## Backup
+
+set t [clock format [clock seconds] -format "%Y-%m-%d_%H-%M"]
+catch {console show}
+file mkdir "./cvs"
+foreach f0 [glob -nocomplain [file join "./" *]] {
+    if {[file isfile $f0]} {
+        set f [file tail $f0]
+        set n [file rootname $f]
+        set x [file extension $f]
+        set t0 [file mtime $f0]
+        set ts0 [clock format $t0 -format "%Y-%m-%d_%H-%M"]
+        #if {$f!=[file tail $::argv0]} {
+            set f1 "./cvs/$n.$ts0$x"
+            if {![file exists $f1]} { 
+                puts "copy $f0 $f1"
+                file copy $f0 $f1
+            }
+        #}
+    }
+}
diff --git a/parser/pkgIndex.tcl b/parser/pkgIndex.tcl
old mode 100644
new mode 100755
diff --git a/parser/tclParser.c b/parser/tclParser.c
old mode 100644
new mode 100755
diff --git a/parser/tclparser.dll b/parser/tclparser.dll
old mode 100644
new mode 100755
diff --git a/parser/tclparser.so b/parser/tclparser.so
old mode 100644
new mode 100755
diff --git a/pkgIndex.tcl b/pkgIndex.tcl
old mode 100644
new mode 100755
diff --git a/tsp-clang.tcl b/tsp-clang.tcl
old mode 100644
new mode 100755
diff --git a/tsp-compile.tcl b/tsp-compile.tcl
old mode 100644
new mode 100755
diff --git a/tsp-expr.tcl b/tsp-expr.tcl
old mode 100644
new mode 100755
diff --git a/tsp-generate-control.tcl b/tsp-generate-control.tcl
old mode 100644
new mode 100755
diff --git a/tsp-generate-list.tcl b/tsp-generate-list.tcl
old mode 100644
new mode 100755
diff --git a/tsp-generate-math.tcl b/tsp-generate-math.tcl
old mode 100644
new mode 100755
diff --git a/tsp-generate-set.tcl b/tsp-generate-set.tcl
old mode 100644
new mode 100755
diff --git a/tsp-generate-string.tcl b/tsp-generate-string.tcl
old mode 100644
new mode 100755
diff --git a/tsp-generate-var.tcl b/tsp-generate-var.tcl
old mode 100644
new mode 100755
diff --git a/tsp-generate.tcl b/tsp-generate.tcl
old mode 100644
new mode 100755
diff --git a/tsp-logging.tcl b/tsp-logging.tcl
old mode 100644
new mode 100755
diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
old mode 100644
new mode 100755
diff --git a/tsp-parse.tcl b/tsp-parse.tcl
old mode 100644
new mode 100755
diff --git a/tsp-trace.tcl b/tsp-trace.tcl
old mode 100644
new mode 100755
diff --git a/tsp-types.tcl b/tsp-types.tcl
old mode 100644
new mode 100755
diff --git a/tsp.tcl b/tsp.tcl
old mode 100644
new mode 100755

From ee51e7ef09a44eea420c12c61288f9b645450ce0 Mon Sep 17 00:00:00 2001
From: tcllab <97413632+tcllab@users.noreply.github.com>
Date: Fri, 22 Jul 2022 02:16:39 -0500
Subject: [PATCH 25/39] change parser version num to make pkgIndex and lib file
 agree

---
 parser/pkgIndex.tcl | 2 +-
 tests/tsp_fib.tcl   | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/parser/pkgIndex.tcl b/parser/pkgIndex.tcl
index 360dd31..9082eba 100755
--- a/parser/pkgIndex.tcl
+++ b/parser/pkgIndex.tcl
@@ -1 +1 @@
-package ifneeded parser 0.1 [list load [file join $dir tclparser[info sharedlibextension]]]
+package ifneeded parser 1.001 [list load [file join $dir tclparser[info sharedlibextension]]]
diff --git a/tests/tsp_fib.tcl b/tests/tsp_fib.tcl
index da8d88a..72cee3a 100644
--- a/tests/tsp_fib.tcl
+++ b/tests/tsp_fib.tcl
@@ -1,6 +1,9 @@
 
 package require tsp
+
+if {$::tcl_platform(platform) eq "java"} {
 hyde::configure -compiler javac
+}
 
 tsp::proc tsp_fib {n} {
     #tsp::procdef int -args int

From b51fab54b675b102c1d4c0389c40150210ea4ac2 Mon Sep 17 00:00:00 2001
From: tcllab <97413632+tcllab@users.noreply.github.com>
Date: Sat, 23 Jul 2022 12:45:25 -0500
Subject: [PATCH 26/39] Remove cvs folder.

---
 native/clang/cvs/TSP_cmd.2015-07-28_21-19.c   | 1679 ----------------
 native/clang/cvs/TSP_cmd.2022-04-28_18-24.c   | 1683 ----------------
 native/clang/cvs/TSP_cmd.2022-07-01_14-56.c   | 1683 ----------------
 native/clang/cvs/TSP_cmd.2022-07-01_16-28.c   | 1689 -----------------
 native/clang/cvs/TSP_func.2022-04-23_07-49.c  |  426 -----
 native/clang/cvs/TSP_func.2022-04-25_14-34.c  |  461 -----
 native/clang/cvs/TSP_func.2022-05-13_12-11.c  |  462 -----
 native/clang/cvs/TSP_func.2022-05-16_19-15.c  |  464 -----
 native/clang/cvs/TSP_func.2022-07-01_14-53.c  |  464 -----
 native/clang/cvs/TSP_func.2022-07-01_16-24.c  |  464 -----
 native/clang/cvs/TSP_util.2015-07-28_21-19.c  |  304 ---
 native/clang/cvs/TSP_util.2022-04-24_23-21.c  |  304 ---
 native/clang/cvs/TSP_util.2022-05-13_12-25.c  |  313 ---
 native/clang/cvs/TSP_util.2022-07-01_14-55.c  |  313 ---
 native/clang/cvs/TSP_util.2022-07-01_16-24.c  |  313 ---
 .../clang/cvs/backup_n.2021-07-30_16-32.tcl   |   23 -
 16 files changed, 11045 deletions(-)
 delete mode 100755 native/clang/cvs/TSP_cmd.2015-07-28_21-19.c
 delete mode 100755 native/clang/cvs/TSP_cmd.2022-04-28_18-24.c
 delete mode 100755 native/clang/cvs/TSP_cmd.2022-07-01_14-56.c
 delete mode 100755 native/clang/cvs/TSP_cmd.2022-07-01_16-28.c
 delete mode 100755 native/clang/cvs/TSP_func.2022-04-23_07-49.c
 delete mode 100755 native/clang/cvs/TSP_func.2022-04-25_14-34.c
 delete mode 100755 native/clang/cvs/TSP_func.2022-05-13_12-11.c
 delete mode 100755 native/clang/cvs/TSP_func.2022-05-16_19-15.c
 delete mode 100755 native/clang/cvs/TSP_func.2022-07-01_14-53.c
 delete mode 100755 native/clang/cvs/TSP_func.2022-07-01_16-24.c
 delete mode 100755 native/clang/cvs/TSP_util.2015-07-28_21-19.c
 delete mode 100755 native/clang/cvs/TSP_util.2022-04-24_23-21.c
 delete mode 100755 native/clang/cvs/TSP_util.2022-05-13_12-25.c
 delete mode 100755 native/clang/cvs/TSP_util.2022-07-01_14-55.c
 delete mode 100755 native/clang/cvs/TSP_util.2022-07-01_16-24.c
 delete mode 100755 native/clang/cvs/backup_n.2021-07-30_16-32.tcl

diff --git a/native/clang/cvs/TSP_cmd.2015-07-28_21-19.c b/native/clang/cvs/TSP_cmd.2015-07-28_21-19.c
deleted file mode 100755
index 8331765..0000000
--- a/native/clang/cvs/TSP_cmd.2015-07-28_21-19.c
+++ /dev/null
@@ -1,1679 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-/* return a pointer to a user direct command function, assumes
-   that user command puts the inner direct command into clientdata */
-
-void*
-TSP_User_getCmd(Tcl_Interp* interp, char* cmd) {
-    Tcl_CmdInfo cmdInfo;
-    int rc;
-    Tcl_ObjCmdProc* objCmd;
-    void* userCmd = NULL;
-    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
-    if (rc == 0) {
-        Tcl_Panic("TSP_User_getCmd: can't get command proc for %s", cmd);
-    } else {
-        objCmd = cmdInfo.objProc;
-        rc = objCmd(&userCmd, interp, 0, NULL);
-    }
-     return userCmd;
-}
-
-/* return a pointer to a Tcl command info */
-/* cmd info data is not preserved across multiple calls */
-
-Tcl_CmdInfo*
-TSP_Cmd_getCmdInfo(Tcl_Interp* interp, char* cmd) {
-    static Tcl_CmdInfo cmdInfo;
-    int rc;
-    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
-    if (rc == 0) {
-        Tcl_Panic("TSP_Cmd_getCmdInfo: can't get command proc for %s", cmd);
-    }
-     return &cmdInfo;
-}
-
-
-/* builtins command - a function that calls the builtin and fills in command obj name */
-
-int
-TSP_Cmd_builtin_after (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::after");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("after", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_append (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::append");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("append", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_apply (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::apply");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("apply", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_array (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::array");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("array", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_binary (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::binary");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("binary", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_break (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::break");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("break", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_case (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::case");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("case", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_catch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::catch");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("catch", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_cd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::cd");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("cd", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_chan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::chan");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("chan", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_clock (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::clock");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("clock", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_close (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::close");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("close", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_concat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::concat");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("concat", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_continue (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::continue");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("continue", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_dict (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::dict");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("dict", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_encoding (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::encoding");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("encoding", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_eof (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eof");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("eof", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_error (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::error");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("error", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_eval (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eval");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("eval", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_exec (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exec");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("exec", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_exit (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exit");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("exit", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_expr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::expr");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("expr", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_fblocked (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fblocked");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fblocked", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_fconfigure (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fconfigure");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fconfigure", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_fcopy (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fcopy");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fcopy", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_file (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::file");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("file", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_fileevent (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fileevent");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fileevent", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_flush (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::flush");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("flush", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_for (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::for");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("for", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_foreach (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::foreach");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("foreach", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_format (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::format");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("format", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_gets (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::gets");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("gets", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_glob (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::glob");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("glob", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_global (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::global");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("global", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_if (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::if");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("if", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_incr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::incr");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("incr", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_info (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::info");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("info", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_interp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::interp");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("interp", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_join (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::join");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("join", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lappend (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lappend");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lappend", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lassign (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lassign");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lassign", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lindex (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lindex");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lindex", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_linsert (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::linsert");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("linsert", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_list (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::list");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("list", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_llength (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::llength");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("llength", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lmap (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lmap");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lmap", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_load (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::load");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("load", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lrange (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrange");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lrange", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lrepeat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrepeat");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lrepeat", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lreplace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreplace");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lreplace", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lreverse (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreverse");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lreverse", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lsearch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsearch");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lsearch", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lset");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lset", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lsort (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsort");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lsort", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_namespace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::namespace");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("namespace", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_open (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::open");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("open", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_package (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::package");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("package", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_pid (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pid");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("pid", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_proc (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::proc");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("proc", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_puts (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::puts");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("puts", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_pwd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pwd");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("pwd", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_read (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::read");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("read", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_regexp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regexp");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("regexp", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_regsub (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regsub");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("regsub", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_rename (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::rename");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("rename", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_return (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::return");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("return", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_scan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::scan");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("scan", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_seek (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::seek");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("seek", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_set (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::set");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("set", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_socket (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::socket");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("socket", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_source (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::source");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("source", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_split (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::split");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("split", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_string (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::string");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("string", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_subst (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::subst");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("subst", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_switch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::switch");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("switch", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_tailcall (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tailcall");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("tailcall", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_tell (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tell");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("tell", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_time (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::time");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("time", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_trace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::trace");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("trace", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_try (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::try");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("try", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_unload (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unload");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("unload", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_unset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unset");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("unset", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_update (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::update");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("update", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_uplevel (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::uplevel");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("uplevel", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_upvar (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::upvar");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("upvar", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_variable (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::variable");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("variable", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_vwait (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::vwait");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("vwait", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_while (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::while");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("while", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_yield (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yield");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("yield", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_yieldto (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yieldto");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("yieldto", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_zlib (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::zlib");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("zlib", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-
diff --git a/native/clang/cvs/TSP_cmd.2022-04-28_18-24.c b/native/clang/cvs/TSP_cmd.2022-04-28_18-24.c
deleted file mode 100755
index 511819d..0000000
--- a/native/clang/cvs/TSP_cmd.2022-04-28_18-24.c
+++ /dev/null
@@ -1,1683 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-/* return a pointer to a user direct command function, assumes
-   that user command puts the inner direct command into clientdata */
-
-void*
-TSP_User_getCmd(Tcl_Interp* interp, char* cmd) {
-    Tcl_CmdInfo cmdInfo;
-    int rc;
-    Tcl_ObjCmdProc* objCmd;
-    void* userCmd = NULL;
-    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
-    if (rc == 0) {
-        Tcl_Panic("TSP_User_getCmd: can't get command proc for %s", cmd);
-    } else {
-        objCmd = cmdInfo.objProc;
-        rc = objCmd(&userCmd, interp, 0, NULL);
-    }
-     return userCmd;
-}
-
-/* return a pointer to a Tcl command info */
-/* cmd info data is not preserved across multiple calls */
-
-Tcl_CmdInfo*
-TSP_Cmd_getCmdInfo(Tcl_Interp* interp, char* cmd) {
-    static Tcl_CmdInfo cmdInfo;
-    int rc;
-    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
-    if (rc == 0) {
-        Tcl_Panic("TSP_Cmd_getCmdInfo: can't get command proc for %s", cmd);
-    }
-     return &cmdInfo;
-}
-
-
-/* builtins command - a function that calls the builtin and fills in command obj name */
-
-int
-TSP_Cmd_builtin_after (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::after");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("after", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_append (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::append");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("append", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_apply (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::apply");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("apply", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_array (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::array");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("array", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_binary (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::binary");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("binary", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_break (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::break");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("break", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_case (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::case");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("case", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_catch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::catch");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("catch", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_cd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::cd");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("cd", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_chan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::chan");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("chan", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_clock (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    static int result;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::clock");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("clock", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    // somehow we have to reset the proc, or this risks to crash
-    result= (cmdProc)(clientData, interp, objc, objv);
-    cmdProc = NULL;
-    return result;
-}
-
-int
-TSP_Cmd_builtin_close (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::close");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("close", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_concat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::concat");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("concat", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_continue (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::continue");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("continue", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_dict (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::dict");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("dict", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_encoding (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::encoding");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("encoding", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_eof (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eof");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("eof", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_error (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::error");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("error", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_eval (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eval");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("eval", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_exec (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exec");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("exec", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_exit (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exit");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("exit", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_expr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::expr");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("expr", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_fblocked (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fblocked");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fblocked", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_fconfigure (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fconfigure");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fconfigure", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_fcopy (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fcopy");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fcopy", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_file (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::file");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("file", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_fileevent (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fileevent");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fileevent", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_flush (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::flush");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("flush", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_for (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::for");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("for", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_foreach (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::foreach");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("foreach", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_format (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::format");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("format", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_gets (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::gets");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("gets", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_glob (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::glob");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("glob", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_global (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::global");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("global", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_if (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::if");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("if", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_incr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::incr");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("incr", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_info (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::info");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("info", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_interp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::interp");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("interp", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_join (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::join");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("join", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lappend (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lappend");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lappend", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lassign (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lassign");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lassign", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lindex (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lindex");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lindex", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_linsert (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::linsert");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("linsert", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_list (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::list");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("list", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_llength (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::llength");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("llength", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lmap (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lmap");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lmap", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_load (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::load");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("load", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lrange (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrange");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lrange", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lrepeat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrepeat");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lrepeat", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lreplace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreplace");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lreplace", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lreverse (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreverse");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lreverse", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lsearch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsearch");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lsearch", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lset");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lset", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_lsort (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsort");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lsort", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_namespace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::namespace");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("namespace", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_open (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::open");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("open", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_package (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::package");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("package", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_pid (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pid");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("pid", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_proc (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::proc");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("proc", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_puts (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::puts");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("puts", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_pwd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pwd");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("pwd", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_read (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::read");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("read", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_regexp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regexp");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("regexp", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_regsub (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regsub");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("regsub", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_rename (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::rename");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("rename", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_return (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::return");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("return", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_scan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::scan");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("scan", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_seek (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::seek");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("seek", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_set (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::set");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("set", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_socket (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::socket");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("socket", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_source (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::source");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("source", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_split (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::split");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("split", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_string (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::string");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("string", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_subst (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::subst");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("subst", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_switch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::switch");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("switch", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_tailcall (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tailcall");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("tailcall", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_tell (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tell");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("tell", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_time (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::time");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("time", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_trace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::trace");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("trace", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_try (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::try");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("try", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_unload (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unload");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("unload", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_unset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unset");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("unset", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_update (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::update");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("update", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_uplevel (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::uplevel");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("uplevel", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_upvar (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::upvar");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("upvar", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_variable (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::variable");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("variable", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_vwait (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::vwait");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("vwait", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_while (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::while");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("while", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_yield (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yield");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("yield", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_yieldto (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yieldto");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("yieldto", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-int
-TSP_Cmd_builtin_zlib (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::zlib");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("zlib", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-
diff --git a/native/clang/cvs/TSP_cmd.2022-07-01_14-56.c b/native/clang/cvs/TSP_cmd.2022-07-01_14-56.c
deleted file mode 100755
index d3bd013..0000000
--- a/native/clang/cvs/TSP_cmd.2022-07-01_14-56.c
+++ /dev/null
@@ -1,1683 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-/* return a pointer to a user direct command function, assumes
-   that user command puts the inner direct command into clientdata */
-
-void*
-TSP_User_getCmd(Tcl_Interp* interp, char* cmd) {
-    Tcl_CmdInfo cmdInfo;
-    int rc;
-    Tcl_ObjCmdProc* objCmd;
-    void* userCmd = NULL;
-    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
-    if (rc == 0) {
-        Tcl_Panic("TSP_User_getCmd: can't get command proc for %s", cmd);
-    } else {
-        objCmd = cmdInfo.objProc;
-        rc = objCmd(&userCmd, interp, 0, NULL);
-    }
-     return userCmd;
-}
-
-/* return a pointer to a Tcl command info */
-/* cmd info data is not preserved across multiple calls */
-
-Tcl_CmdInfo*
-TSP_Cmd_getCmdInfo(Tcl_Interp* interp, char* cmd) {
-    static Tcl_CmdInfo cmdInfo;
-    int rc;
-    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
-    if (rc == 0) {
-        Tcl_Panic("TSP_Cmd_getCmdInfo: can't get command proc for %s", cmd);
-    }
-     return &cmdInfo;
-}
-
-
-/* builtins command - a function that calls the builtin and fills in command obj name */
-
-static inline int
-TSP_Cmd_builtin_after (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::after");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("after", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_append (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::append");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("append", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_apply (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::apply");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("apply", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_array (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::array");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("array", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_binary (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::binary");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("binary", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_break (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::break");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("break", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_case (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::case");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("case", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_catch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::catch");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("catch", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_cd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::cd");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("cd", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_chan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::chan");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("chan", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_clock (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    static int result;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::clock");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("clock", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    // somehow we have to reset the proc, or this risks to crash
-    result= (cmdProc)(clientData, interp, objc, objv);
-    cmdProc = NULL;
-    return result;
-}
-
-static inline int
-TSP_Cmd_builtin_close (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::close");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("close", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_concat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::concat");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("concat", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_continue (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::continue");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("continue", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_dict (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::dict");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("dict", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_encoding (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::encoding");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("encoding", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_eof (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eof");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("eof", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_error (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::error");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("error", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_eval (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eval");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("eval", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_exec (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exec");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("exec", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_exit (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exit");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("exit", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_expr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::expr");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("expr", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_fblocked (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fblocked");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fblocked", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_fconfigure (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fconfigure");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fconfigure", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_fcopy (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fcopy");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fcopy", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_file (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::file");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("file", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_fileevent (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fileevent");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fileevent", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_flush (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::flush");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("flush", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_for (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::for");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("for", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_foreach (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::foreach");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("foreach", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_format (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::format");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("format", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_gets (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::gets");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("gets", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_glob (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::glob");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("glob", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_global (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::global");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("global", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_if (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::if");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("if", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_incr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::incr");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("incr", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_info (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::info");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("info", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_interp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::interp");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("interp", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_join (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::join");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("join", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_lappend (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lappend");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lappend", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_lassign (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lassign");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lassign", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_lindex (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lindex");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lindex", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_linsert (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::linsert");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("linsert", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_list (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::list");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("list", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_llength (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::llength");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("llength", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_lmap (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lmap");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lmap", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_load (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::load");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("load", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_lrange (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrange");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lrange", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_lrepeat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrepeat");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lrepeat", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_lreplace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreplace");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lreplace", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_lreverse (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreverse");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lreverse", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_lsearch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsearch");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lsearch", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_lset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lset");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lset", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_lsort (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsort");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lsort", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_namespace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::namespace");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("namespace", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_open (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::open");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("open", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_package (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::package");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("package", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_pid (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pid");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("pid", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_proc (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::proc");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("proc", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_puts (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::puts");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("puts", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_pwd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pwd");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("pwd", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_read (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::read");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("read", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_regexp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regexp");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("regexp", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_regsub (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regsub");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("regsub", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_rename (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::rename");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("rename", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_return (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::return");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("return", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_scan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::scan");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("scan", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_seek (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::seek");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("seek", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_set (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::set");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("set", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_socket (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::socket");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("socket", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_source (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::source");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("source", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_split (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::split");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("split", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_string (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::string");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("string", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_subst (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::subst");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("subst", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_switch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::switch");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("switch", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_tailcall (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tailcall");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("tailcall", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_tell (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tell");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("tell", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_time (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::time");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("time", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_trace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::trace");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("trace", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_try (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::try");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("try", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_unload (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unload");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("unload", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_unset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unset");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("unset", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_update (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::update");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("update", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_uplevel (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::uplevel");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("uplevel", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_upvar (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::upvar");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("upvar", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_variable (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::variable");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("variable", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_vwait (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::vwait");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("vwait", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_while (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::while");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("while", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_yield (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yield");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("yield", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_yieldto (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yieldto");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("yieldto", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-static inline int
-TSP_Cmd_builtin_zlib (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::zlib");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("zlib", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-
diff --git a/native/clang/cvs/TSP_cmd.2022-07-01_16-28.c b/native/clang/cvs/TSP_cmd.2022-07-01_16-28.c
deleted file mode 100755
index e587ea3..0000000
--- a/native/clang/cvs/TSP_cmd.2022-07-01_16-28.c
+++ /dev/null
@@ -1,1689 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-/* return a pointer to a user direct command function, assumes
-   that user command puts the inner direct command into clientdata */
-
-void*
-TSP_User_getCmd(Tcl_Interp* interp, char* cmd) {
-    Tcl_CmdInfo cmdInfo;
-    int rc;
-    Tcl_ObjCmdProc* objCmd;
-    void* userCmd = NULL;
-    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
-    if (rc == 0) {
-        Tcl_Panic("TSP_User_getCmd: can't get command proc for %s", cmd);
-    } else {
-        objCmd = cmdInfo.objProc;
-        rc = objCmd(&userCmd, interp, 0, NULL);
-    }
-     return userCmd;
-}
-
-/* return a pointer to a Tcl command info */
-/* cmd info data is not preserved across multiple calls */
-
-Tcl_CmdInfo*
-TSP_Cmd_getCmdInfo(Tcl_Interp* interp, char* cmd) {
-    static Tcl_CmdInfo cmdInfo;
-    int rc;
-    rc = Tcl_GetCommandInfo(interp, cmd, &cmdInfo);
-    if (rc == 0) {
-        Tcl_Panic("TSP_Cmd_getCmdInfo: can't get command proc for %s", cmd);
-    }
-     return &cmdInfo;
-}
-
-/* define TSP_REMOVABLE as static inline     to enable tcc dead code elimination */
-#ifdef __TINYC__
-#define TSP_REMOVABLE static inline 
-#else
-#define TSP_REMOVABLE static
-#endif
-
-/* builtins command - a function that calls the builtin and fills in command obj name */
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_after (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::after");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("after", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_append (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::append");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("append", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_apply (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::apply");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("apply", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_array (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::array");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("array", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_binary (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::binary");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("binary", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_break (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::break");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("break", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_case (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::case");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("case", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_catch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::catch");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("catch", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_cd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::cd");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("cd", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_chan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::chan");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("chan", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_clock (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    static int result;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::clock");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("clock", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    // somehow we have to reset the proc, or this risks to crash
-    result= (cmdProc)(clientData, interp, objc, objv);
-    cmdProc = NULL;
-    return result;
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_close (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::close");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("close", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_concat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::concat");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("concat", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_continue (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::continue");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("continue", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_dict (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::dict");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("dict", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_encoding (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::encoding");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("encoding", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_eof (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eof");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("eof", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_error (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::error");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("error", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_eval (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::eval");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("eval", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_exec (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exec");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("exec", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_exit (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::exit");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("exit", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_expr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::expr");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("expr", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_fblocked (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fblocked");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fblocked", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_fconfigure (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fconfigure");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fconfigure", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_fcopy (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fcopy");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fcopy", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_file (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::file");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("file", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_fileevent (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::fileevent");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("fileevent", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_flush (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::flush");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("flush", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_for (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::for");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("for", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_foreach (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::foreach");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("foreach", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_format (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::format");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("format", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_gets (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::gets");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("gets", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_glob (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::glob");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("glob", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_global (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::global");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("global", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_if (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::if");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("if", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_incr (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::incr");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("incr", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_info (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::info");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("info", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_interp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::interp");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("interp", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_join (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::join");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("join", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_lappend (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lappend");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lappend", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_lassign (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lassign");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lassign", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_lindex (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lindex");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lindex", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_linsert (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::linsert");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("linsert", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_list (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::list");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("list", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_llength (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::llength");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("llength", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_lmap (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lmap");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lmap", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_load (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::load");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("load", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_lrange (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrange");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lrange", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_lrepeat (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lrepeat");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lrepeat", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_lreplace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreplace");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lreplace", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_lreverse (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lreverse");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lreverse", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_lsearch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsearch");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lsearch", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_lset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lset");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lset", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_lsort (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::lsort");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("lsort", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_namespace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::namespace");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("namespace", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_open (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::open");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("open", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_package (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::package");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("package", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_pid (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pid");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("pid", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_proc (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::proc");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("proc", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_puts (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::puts");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("puts", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_pwd (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::pwd");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("pwd", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_read (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::read");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("read", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_regexp (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regexp");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("regexp", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_regsub (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::regsub");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("regsub", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_rename (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::rename");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("rename", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_return (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::return");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("return", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_scan (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::scan");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("scan", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_seek (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::seek");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("seek", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_set (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::set");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("set", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_socket (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::socket");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("socket", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_source (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::source");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("source", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_split (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::split");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("split", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_string (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::string");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("string", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_subst (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::subst");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("subst", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_switch (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::switch");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("switch", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_tailcall (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tailcall");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("tailcall", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_tell (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::tell");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("tell", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_time (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::time");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("time", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_trace (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::trace");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("trace", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_try (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::try");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("try", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_unload (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unload");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("unload", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_unset (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::unset");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("unset", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_update (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::update");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("update", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_uplevel (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::uplevel");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("uplevel", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_upvar (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::upvar");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("upvar", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_variable (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::variable");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("variable", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_vwait (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::vwait");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("vwait", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_while (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::while");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("while", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_yield (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yield");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("yield", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_yieldto (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::yieldto");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("yieldto", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-TSP_REMOVABLE int
-TSP_Cmd_builtin_zlib (ClientData dummy, Tcl_Interp* interp, int objc, struct Tcl_Obj *objv[]) {
-    static Tcl_ObjCmdProc* cmdProc = NULL;
-    static Tcl_Obj* cmdName = NULL;
-    static ClientData clientData = NULL;
-    if (cmdProc == NULL) {
-        Tcl_CmdInfo* cmdInfo;
-        cmdInfo = TSP_Cmd_getCmdInfo(interp, "::zlib");
-        cmdProc = cmdInfo->objProc;
-        clientData = cmdInfo->objClientData;
-        cmdName = Tcl_NewStringObj("zlib", -1);
-        Tcl_IncrRefCount(cmdName);  /* make cmdName safe */
-        Tcl_IncrRefCount(cmdName);  /* from altercation  */
-    }
-    objv[0] = cmdName;
-    return (cmdProc)(clientData, interp, objc, objv);
-}
-
-
diff --git a/native/clang/cvs/TSP_func.2022-04-23_07-49.c b/native/clang/cvs/TSP_func.2022-04-23_07-49.c
deleted file mode 100755
index 8c0b5bc..0000000
--- a/native/clang/cvs/TSP_func.2022-04-23_07-49.c
+++ /dev/null
@@ -1,426 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-#ifndef _MATH_H
-#include <math.h>
-#endif
-#include <stdlib.h>
-
-#ifndef _LIBC_LIMITS_H_
-#include <limits.h>
-#endif
-
-
-#define TRUE 1
-#define FALSE 0
-#define TSP_DIV_BY_ZERO "divide by zero"
-#define TSP_DOMAIN_ERROR "domain error"
-
-/* only record the first error */
-#define RAISE_ERROR(m) *rc = TCL_ERROR; if (*exprErrMsg == NULL) *exprErrMsg = m; return 0
-
-#define CHECK_NAN(a) if (isnan(a)) return NAN
-
-/* functions that can raise errors have macros to add rc and exprErrMsg parameters */
-
-#define TSP_func_int_div(a,b) _TSP_func_int_div(rc, &exprErrMsg, (a), (b))
-Tcl_WideInt
-_TSP_func_int_div(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
-    Tcl_WideInt quotient;
-
-    if (divisor == 0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " IntDiv()");
-    }
-    if (dividend == LLONG_MIN && divisor == -1) {
-        /* Avoid integer overflow on (Long.MIN_VALUE / -1) */
-        quotient = LLONG_MIN;
-    } else {
-        quotient = dividend / divisor;
-        /* Round down to a smaller negative number if  */
-        /* there is a remainder and the quotient is    */
-        /* negative or zero and the signs don't match. */
-        if (((quotient < 0) || ((quotient == 0) && (((dividend < 0) && (divisor > 0)) || ((dividend > 0)
-                    && (divisor < 0))))) && ((quotient * divisor) != dividend)) {
-            quotient -= 1;
-        }
-    }
-    return quotient;
-}
-
-
-#define TSP_func_int_mod(a,b) _TSP_func_int_mod(rc, &exprErrMsg, (a), (b))
-Tcl_WideInt
-_TSP_func_int_mod(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
-    Tcl_WideInt remainder = 0;
-    int neg_divisor = 0;
-
-    if (divisor == 0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " IntMod()");
-    }
-
-    if (dividend == LLONG_MIN && divisor == -1) {
-        remainder = 0;
-    } else {
-        if (divisor < 0) {
-            divisor = -divisor;
-            dividend = -dividend;
-            neg_divisor = 1;
-        }
-        remainder = dividend % divisor;
-        if (remainder < 0
-                && !(neg_divisor && (dividend == LLONG_MIN))) {
-            remainder += divisor;
-        }
-    }
-    if ((neg_divisor && (remainder > 0))
-                || (!neg_divisor && (remainder < 0))) {
-        remainder = -remainder;
-    }
-    return remainder;
-}
-
-
-#define TSP_func_double_div(a,b) _TSP_func_double_div(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_double_div(int* rc, char** exprErrMsg, double x, double y) {
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    if (y == 0.0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " DoubleDiv()");
-    } else {
-        return x / y;
-    }
-}
-
-int
-TSP_func_util_strcmp(Tcl_DString* s1, Tcl_DString* s2) {
-    int match;
-    int length1 = Tcl_DStringLength(s1);
-    int length2 = Tcl_DStringLength(s2);
-    length1 = Tcl_NumUtfChars(Tcl_DStringValue(s1), length1);
-    length2 = Tcl_NumUtfChars(Tcl_DStringValue(s2), length2);
-    match = Tcl_UtfNcmp(Tcl_DStringValue(s1), Tcl_DStringValue(s2), (length1 < length2) ? length1 : length2);
-    if (match == 0) {
-        return length1 - length2;
-    } else {
-        return match;
-    }
-}
-
-int
-TSP_func_str_lt(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) < 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_gt(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) > 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_le(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) <= 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_ge(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) >= 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_eq(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) == 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_ne(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) != 0) ? TRUE : FALSE;
-}
-
-Tcl_WideInt
-TSP_func_int_abs(Tcl_WideInt i) {
-    if (i < 0) {
-        if (i == LLONG_MIN) {
-            return 0;
-        } else {
-            return i * -1;
-        }
-    } else {
-        return i;
-    }
-}
-
-double
-TSP_func_double_abs(double x) {
-    CHECK_NAN(x);
-    if (x < 0) {
-        return x * -1.0;
-    } else {
-        return x;
-    }
-}
-
-#define TSP_func_acos(a)  _TSP_func_acos(rc, &exprErrMsg, (a))
-double
-_TSP_func_acos(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = acos(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " acos()");
-    }
-    return z;
-}
-
-#define TSP_func_asin(a) _TSP_func_asin(rc, &exprErrMsg, (a))
-double
-_TSP_func_asin(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = asin(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " asin()");
-    }
-    return z;
-}
-
-#define TSP_func_atan(a) _TSP_func_atan(rc, &exprErrMsg, (a))
-double
-_TSP_func_atan(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = atan(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " atan()");
-    }
-    return z;
-}
-
-#define TSP_func_atan2(a,b) _TSP_func_atan2(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_atan2(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = atan2(x, y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " atan2()");
-    }
-    return z;
-}
-
-#define TSP_func_ceil(a)  _TSP_func_ceil(rc, &exprErrMsg, (a))
-double
-_TSP_func_ceil(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = ceil(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " ceil()");
-    }
-    return z;
-}
-
-#define TSP_func_cos(a) _TSP_func_cos(rc, &exprErrMsg, (a))
-double
-_TSP_func_cos(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = cos(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " cos()");
-    }
-    return z;
-}
-
-#define TSP_func_cosh(a) _TSP_func_cosh(rc, &exprErrMsg, (a))
-double
-_TSP_func_cosh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = cosh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " cosh()");
-    }
-    return z;
-}
-
-#define TSP_func_exp(a) _TSP_func_exp(rc, &exprErrMsg, (a))
-double
-_TSP_func_exp(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = exp(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " exp()");
-    }
-    return z;
-}
-
-#define TSP_func_floor(a) _TSP_func_floor(rc, &exprErrMsg, (a))
-double
-_TSP_func_floor(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = floor(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " floor()");
-    }
-    return z;
-}
-
-#define TSP_func_fmod(a) _TSP_func_fmod(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_fmod(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = fmod(x, y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " fmod()");
-    }
-    return z;
-}
-
-#define TSP_func_hypot(a,b) _TSP_func_hypot(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_hypot(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = hypot(x, y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " hypot()");
-    }
-    return z;
-}
-
-#define TSP_func_log(a) _TSP_func_log(rc, &exprErrMsg, (a))
-double
-_TSP_func_log(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = log(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " log()");
-    }
-    return z;
-}
-
-#define TSP_func_log10(a) _TSP_func_log10(rc, &exprErrMsg, (a))
-double
-_TSP_func_log10(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = log(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " log10()");
-    }
-    return z;
-}
-
-#define TSP_func_pow(a,b) _TSP_func_pow(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = pow(x, y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
-    }
-    return z;
-}
-
-#define TSP_func_int_pow(a,b) _TSP_func_int_pow(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
-    double z;
-    CHECK_NAN(x);
-    z = pow(x, (double) y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
-    }
-    return z;
-}
-
-
-double
-TSP_func_rand() {
-    return rand(); 
-}
-
-double
-TSP_func_round(double x) {
-    return round(x);
-}
-
-#define TSP_func_sin(a) _TSP_func_sin(rc, &exprErrMsg, (a))
-double
-_TSP_func_sin(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sin(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sin()");
-    }
-    return z;
-}
-
-#define TSP_func_sinh(a) _TSP_func_sinh(rc, &exprErrMsg, (a))
-double
-_TSP_func_sinh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sinh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sinh()");
-    }
-    return z;
-}
-
-#define TSP_func_sqrt(a) _TSP_func_sqrt(rc, &exprErrMsg, (a))
-double
-_TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sqrt(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sqrt()");
-    }
-    return z;
-}
-
-double
-TSP_func_int_srand(Tcl_WideInt i) {
-    srand((long) i);
-    return rand();
-}
-
-#define TSP_func_tan(a) _TSP_func_tan(rc, &exprErrMsg, (a))
-double
-_TSP_func_tan(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = tan(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " tan()");
-    }
-    return z;
-}
-
-#define TSP_func_tanh(a) _TSP_func_tanh(rc, &exprErrMsg, (a))
-double
-_TSP_func_tanh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = tanh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " tanh()");
-    }
-    return z;
-}
-
-
-
diff --git a/native/clang/cvs/TSP_func.2022-04-25_14-34.c b/native/clang/cvs/TSP_func.2022-04-25_14-34.c
deleted file mode 100755
index cd29697..0000000
--- a/native/clang/cvs/TSP_func.2022-04-25_14-34.c
+++ /dev/null
@@ -1,461 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-#ifndef _MATH_H
-#include <math.h>
-#endif
-#include <stdlib.h>
-
-#ifndef _LIBC_LIMITS_H_
-#include <limits.h>
-#endif
-
-
-#define TRUE 1
-#define FALSE 0
-#define TSP_DIV_BY_ZERO "divide by zero"
-#define TSP_DOMAIN_ERROR "domain error"
-
-/* only record the first error */
-#define RAISE_ERROR(m) *rc = TCL_ERROR; if (*exprErrMsg == NULL) *exprErrMsg = m; return 0
-
-#define CHECK_NAN(a) if (isnan(a)) return NAN
-
-/* functions that can raise errors have macros to add rc and exprErrMsg parameters */
-
-#define TSP_func_int_div(a,b) _TSP_func_int_div(rc, &exprErrMsg, (a), (b))
-Tcl_WideInt
-_TSP_func_int_div(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
-    Tcl_WideInt quotient;
-
-    if (divisor == 0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " IntDiv()");
-    }
-    if (dividend == LLONG_MIN && divisor == -1) {
-        /* Avoid integer overflow on (Long.MIN_VALUE / -1) */
-        quotient = LLONG_MIN;
-    } else {
-        quotient = dividend / divisor;
-        /* Round down to a smaller negative number if  */
-        /* there is a remainder and the quotient is    */
-        /* negative or zero and the signs don't match. */
-        if (((quotient < 0) || ((quotient == 0) && (((dividend < 0) && (divisor > 0)) || ((dividend > 0)
-                    && (divisor < 0))))) && ((quotient * divisor) != dividend)) {
-            quotient -= 1;
-        }
-    }
-    return quotient;
-}
-
-
-#define TSP_func_int_mod(a,b) _TSP_func_int_mod(rc, &exprErrMsg, (a), (b))
-Tcl_WideInt
-_TSP_func_int_mod(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
-    Tcl_WideInt remainder = 0;
-    int neg_divisor = 0;
-
-    if (divisor == 0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " IntMod()");
-    }
-
-    if (dividend == LLONG_MIN && divisor == -1) {
-        remainder = 0;
-    } else {
-        if (divisor < 0) {
-            divisor = -divisor;
-            dividend = -dividend;
-            neg_divisor = 1;
-        }
-        remainder = dividend % divisor;
-        if (remainder < 0
-                && !(neg_divisor && (dividend == LLONG_MIN))) {
-            remainder += divisor;
-        }
-    }
-    if ((neg_divisor && (remainder > 0))
-                || (!neg_divisor && (remainder < 0))) {
-        remainder = -remainder;
-    }
-    return remainder;
-}
-
-
-#define TSP_func_double_div(a,b) _TSP_func_double_div(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_double_div(int* rc, char** exprErrMsg, double x, double y) {
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    if (y == 0.0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " DoubleDiv()");
-    } else {
-        return x / y;
-    }
-}
-
-int
-TSP_func_util_strcmp(Tcl_DString* s1, Tcl_DString* s2) {
-    int match;
-    int length1 = Tcl_DStringLength(s1);
-    int length2 = Tcl_DStringLength(s2);
-    length1 = Tcl_NumUtfChars(Tcl_DStringValue(s1), length1);
-    length2 = Tcl_NumUtfChars(Tcl_DStringValue(s2), length2);
-    match = Tcl_UtfNcmp(Tcl_DStringValue(s1), Tcl_DStringValue(s2), (length1 < length2) ? length1 : length2);
-    if (match == 0) {
-        return length1 - length2;
-    } else {
-        return match;
-    }
-}
-
-int
-TSP_func_str_lt(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) < 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_gt(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) > 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_le(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) <= 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_ge(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) >= 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_eq(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) == 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_ne(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) != 0) ? TRUE : FALSE;
-}
-
-Tcl_WideInt
-TSP_func_int_abs(Tcl_WideInt i) {
-    if (i < 0) {
-        if (i == LLONG_MIN) {
-            return 0;
-        } else {
-            return i * -1;
-        }
-    } else {
-        return i;
-    }
-}
-
-double
-TSP_func_double_abs(double x) {
-    CHECK_NAN(x);
-    if (x < 0) {
-        return x * -1.0;
-    } else {
-        return x;
-    }
-}
-
-#define TSP_func_acos(a)  _TSP_func_acos(rc, &exprErrMsg, (a))
-double
-_TSP_func_acos(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = acos(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " acos()");
-    }
-    return z;
-}
-
-#define TSP_func_asin(a) _TSP_func_asin(rc, &exprErrMsg, (a))
-double
-_TSP_func_asin(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = asin(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " asin()");
-    }
-    return z;
-}
-
-#define TSP_func_atan(a) _TSP_func_atan(rc, &exprErrMsg, (a))
-double
-_TSP_func_atan(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = atan(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " atan()");
-    }
-    return z;
-}
-
-#define TSP_func_atan2(a,b) _TSP_func_atan2(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_atan2(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = atan2(x, y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " atan2()");
-    }
-    return z;
-}
-
-#define TSP_func_ceil(a)  _TSP_func_ceil(rc, &exprErrMsg, (a))
-double
-_TSP_func_ceil(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = ceil(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " ceil()");
-    }
-    return z;
-}
-
-#define TSP_func_cos(a) _TSP_func_cos(rc, &exprErrMsg, (a))
-double
-_TSP_func_cos(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = cos(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " cos()");
-    }
-    return z;
-}
-
-#define TSP_func_cosh(a) _TSP_func_cosh(rc, &exprErrMsg, (a))
-double
-_TSP_func_cosh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = cosh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " cosh()");
-    }
-    return z;
-}
-
-#define TSP_func_exp(a) _TSP_func_exp(rc, &exprErrMsg, (a))
-double
-_TSP_func_exp(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = exp(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " exp()");
-    }
-    return z;
-}
-
-#define TSP_func_floor(a) _TSP_func_floor(rc, &exprErrMsg, (a))
-double
-_TSP_func_floor(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = floor(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " floor()");
-    }
-    return z;
-}
-
-#define TSP_func_fmod(a) _TSP_func_fmod(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_fmod(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = fmod(x, y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " fmod()");
-    }
-    return z;
-}
-
-#define TSP_func_hypot(a,b) _TSP_func_hypot(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_hypot(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = hypot(x, y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " hypot()");
-    }
-    return z;
-}
-
-#define TSP_func_log(a) _TSP_func_log(rc, &exprErrMsg, (a))
-double
-_TSP_func_log(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = log(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " log()");
-    }
-    return z;
-}
-
-#define TSP_func_log10(a) _TSP_func_log10(rc, &exprErrMsg, (a))
-double
-_TSP_func_log10(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = log(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " log10()");
-    }
-    return z;
-}
-
-#define max(a,b) \
-   ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-     _a > _b ? _a : _b; })
-#define TSP_func_max(a,b)  _TSP_func_max(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_max(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = max(x,y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " max()");
-    }
-    return z;
-}
-
-#define min(a,b) \
-   ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-     _a <= _b ? _a : _b; })
-#define TSP_func_min(a,b)  _TSP_func_min(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_min(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = min(x,y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " min()");
-    }
-    return z;
-}
-
-#define TSP_func_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
-#define TSP_func_double_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = pow(x, y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
-    }
-    return z;
-}
-
-#define TSP_func_int_pow(a,b) _TSP_func_double_int_pow(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
-    double z;
-    CHECK_NAN(x);
-    z = pow(x, (double) y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
-    }
-    return z;
-}
-
-
-double
-TSP_func_rand() {
-    return rand(); 
-}
-
-double
-TSP_func_round(double x) {
-    return round(x);
-}
-
-#define TSP_func_sin(a) _TSP_func_sin(rc, &exprErrMsg, (a))
-double
-_TSP_func_sin(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sin(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sin()");
-    }
-    return z;
-}
-
-#define TSP_func_sinh(a) _TSP_func_sinh(rc, &exprErrMsg, (a))
-double
-_TSP_func_sinh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sinh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sinh()");
-    }
-    return z;
-}
-
-#define TSP_func_sqrt(a) _TSP_func_sqrt(rc, &exprErrMsg, (a))
-double
-_TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sqrt(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sqrt()");
-    }
-    return z;
-}
-
-double
-TSP_func_int_srand(Tcl_WideInt i) {
-    srand((long) i);
-    return rand();
-}
-
-#define TSP_func_tan(a) _TSP_func_tan(rc, &exprErrMsg, (a))
-double
-_TSP_func_tan(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = tan(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " tan()");
-    }
-    return z;
-}
-
-#define TSP_func_tanh(a) _TSP_func_tanh(rc, &exprErrMsg, (a))
-double
-_TSP_func_tanh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = tanh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " tanh()");
-    }
-    return z;
-}
-
-
-
diff --git a/native/clang/cvs/TSP_func.2022-05-13_12-11.c b/native/clang/cvs/TSP_func.2022-05-13_12-11.c
deleted file mode 100755
index 7c3cd73..0000000
--- a/native/clang/cvs/TSP_func.2022-05-13_12-11.c
+++ /dev/null
@@ -1,462 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-#ifndef _MATH_H
-#include <math.h>
-#endif
-#include <stdlib.h>
-
-#ifndef _LIBC_LIMITS_H_
-#include <limits.h>
-#endif
-
-
-#define TRUE 1
-#define FALSE 0
-#define TSP_DIV_BY_ZERO "divide by zero"
-#define TSP_DOMAIN_ERROR "domain error"
-
-/* only record the first error */
-#define RAISE_ERROR(m) *rc = TCL_ERROR; if (*exprErrMsg == NULL) *exprErrMsg = m; return 0
-
-#define CHECK_NAN(a) if (isnan(a)) return NAN
-
-/* functions that can raise errors have macros to add rc and exprErrMsg parameters */
-
-#define TSP_func_int_div(a,b) _TSP_func_int_div(rc, &exprErrMsg, (a), (b))
-Tcl_WideInt
-_TSP_func_int_div(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
-    Tcl_WideInt quotient;
-
-    if (divisor == 0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " IntDiv()");
-    }
-    if (dividend == LLONG_MIN && divisor == -1) {
-        /* Avoid integer overflow on (Long.MIN_VALUE / -1) */
-        quotient = LLONG_MIN;
-    } else {
-        quotient = dividend / divisor;
-        /* Round down to a smaller negative number if  */
-        /* there is a remainder and the quotient is    */
-        /* negative or zero and the signs don't match. */
-        if (((quotient < 0) || ((quotient == 0) && (((dividend < 0) && (divisor > 0)) || ((dividend > 0)
-                    && (divisor < 0))))) && ((quotient * divisor) != dividend)) {
-            quotient -= 1;
-        }
-    }
-    return quotient;
-}
-
-
-#define TSP_func_int_mod(a,b) _TSP_func_int_mod(rc, &exprErrMsg, (a), (b))
-Tcl_WideInt
-_TSP_func_int_mod(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
-    Tcl_WideInt remainder = 0;
-    int neg_divisor = 0;
-
-    if (divisor == 0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " IntMod()");
-    }
-
-    if (dividend == LLONG_MIN && divisor == -1) {
-        remainder = 0;
-    } else {
-        if (divisor < 0) {
-            divisor = -divisor;
-            dividend = -dividend;
-            neg_divisor = 1;
-        }
-        remainder = dividend % divisor;
-        if (remainder < 0
-                && !(neg_divisor && (dividend == LLONG_MIN))) {
-            remainder += divisor;
-        }
-    }
-    if ((neg_divisor && (remainder > 0))
-                || (!neg_divisor && (remainder < 0))) {
-        remainder = -remainder;
-    }
-    return remainder;
-}
-
-
-#define TSP_func_double_div(a,b) _TSP_func_double_div(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_double_div(int* rc, char** exprErrMsg, double x, double y) {
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    if (y == 0.0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " DoubleDiv()");
-    } else {
-        return x / y;
-    }
-}
-
-int
-TSP_func_util_strcmp(Tcl_DString* s1, Tcl_DString* s2) {
-    int match;
-    int length1 = Tcl_DStringLength(s1);
-    int length2 = Tcl_DStringLength(s2);
-    length1 = Tcl_NumUtfChars(Tcl_DStringValue(s1), length1);
-    length2 = Tcl_NumUtfChars(Tcl_DStringValue(s2), length2);
-    match = Tcl_UtfNcmp(Tcl_DStringValue(s1), Tcl_DStringValue(s2), (length1 < length2) ? length1 : length2);
-    if (match == 0) {
-        return length1 - length2;
-    } else {
-        return match;
-    }
-}
-
-int
-TSP_func_str_lt(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) < 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_gt(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) > 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_le(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) <= 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_ge(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) >= 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_eq(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) == 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_ne(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) != 0) ? TRUE : FALSE;
-}
-
-
-Tcl_WideInt
-TSP_func_int_abs(Tcl_WideInt i) {
-    if (i < 0) {
-        if (i == LLONG_MIN) {
-            return 0;
-        } else {
-            return i * -1;
-        }
-    } else {
-        return i;
-    }
-}
-
-double
-TSP_func_double_abs(double x) {
-    CHECK_NAN(x);
-    if (x < 0) {
-        return x * -1.0;
-    } else {
-        return x;
-    }
-}
-
-#define TSP_func_acos(a)  _TSP_func_acos(rc, &exprErrMsg, (a))
-double
-_TSP_func_acos(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = acos(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " acos()");
-    }
-    return z;
-}
-
-#define TSP_func_asin(a) _TSP_func_asin(rc, &exprErrMsg, (a))
-double
-_TSP_func_asin(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = asin(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " asin()");
-    }
-    return z;
-}
-
-#define TSP_func_atan(a) _TSP_func_atan(rc, &exprErrMsg, (a))
-double
-_TSP_func_atan(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = atan(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " atan()");
-    }
-    return z;
-}
-
-#define TSP_func_atan2(a,b) _TSP_func_atan2(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_atan2(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = atan2(x, y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " atan2()");
-    }
-    return z;
-}
-
-#define TSP_func_ceil(a)  _TSP_func_ceil(rc, &exprErrMsg, (a))
-double
-_TSP_func_ceil(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = ceil(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " ceil()");
-    }
-    return z;
-}
-
-#define TSP_func_cos(a) _TSP_func_cos(rc, &exprErrMsg, (a))
-double
-_TSP_func_cos(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = cos(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " cos()");
-    }
-    return z;
-}
-
-#define TSP_func_cosh(a) _TSP_func_cosh(rc, &exprErrMsg, (a))
-double
-_TSP_func_cosh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = cosh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " cosh()");
-    }
-    return z;
-}
-
-#define TSP_func_exp(a) _TSP_func_exp(rc, &exprErrMsg, (a))
-double
-_TSP_func_exp(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = exp(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " exp()");
-    }
-    return z;
-}
-
-#define TSP_func_floor(a) _TSP_func_floor(rc, &exprErrMsg, (a))
-double
-_TSP_func_floor(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = floor(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " floor()");
-    }
-    return z;
-}
-
-#define TSP_func_fmod(a) _TSP_func_fmod(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_fmod(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = fmod(x, y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " fmod()");
-    }
-    return z;
-}
-
-#define TSP_func_hypot(a,b) _TSP_func_hypot(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_hypot(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = hypot(x, y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " hypot()");
-    }
-    return z;
-}
-
-#define TSP_func_log(a) _TSP_func_log(rc, &exprErrMsg, (a))
-double
-_TSP_func_log(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = log(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " log()");
-    }
-    return z;
-}
-
-#define TSP_func_log10(a) _TSP_func_log10(rc, &exprErrMsg, (a))
-double
-_TSP_func_log10(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = log(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " log10()");
-    }
-    return z;
-}
-
-#define max(a,b) \
-   ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-     _a > _b ? _a : _b; })
-#define TSP_func_max(a,b)  _TSP_func_max(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_max(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = max(x,y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " max()");
-    }
-    return z;
-}
-
-#define min(a,b) \
-   ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-     _a <= _b ? _a : _b; })
-#define TSP_func_min(a,b)  _TSP_func_min(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_min(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = min(x,y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " min()");
-    }
-    return z;
-}
-
-#define TSP_func_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
-#define TSP_func_double_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = pow(x, y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
-    }
-    return z;
-}
-
-#define TSP_func_int_pow(a,b) _TSP_func_double_int_pow(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
-    double z;
-    CHECK_NAN(x);
-    z = pow(x, (double) y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
-    }
-    return z;
-}
-
-
-double
-TSP_func_rand() {
-    return rand(); 
-}
-
-double
-TSP_func_round(double x) {
-    return round(x);
-}
-
-#define TSP_func_sin(a) _TSP_func_sin(rc, &exprErrMsg, (a))
-double
-_TSP_func_sin(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sin(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sin()");
-    }
-    return z;
-}
-
-#define TSP_func_sinh(a) _TSP_func_sinh(rc, &exprErrMsg, (a))
-double
-_TSP_func_sinh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sinh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sinh()");
-    }
-    return z;
-}
-
-#define TSP_func_sqrt(a) _TSP_func_sqrt(rc, &exprErrMsg, (a))
-double
-_TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sqrt(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sqrt()");
-    }
-    return z;
-}
-
-double
-TSP_func_int_srand(Tcl_WideInt i) {
-    srand((long) i);
-    return rand();
-}
-
-#define TSP_func_tan(a) _TSP_func_tan(rc, &exprErrMsg, (a))
-double
-_TSP_func_tan(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = tan(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " tan()");
-    }
-    return z;
-}
-
-#define TSP_func_tanh(a) _TSP_func_tanh(rc, &exprErrMsg, (a))
-double
-_TSP_func_tanh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = tanh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " tanh()");
-    }
-    return z;
-}
-
-
-
diff --git a/native/clang/cvs/TSP_func.2022-05-16_19-15.c b/native/clang/cvs/TSP_func.2022-05-16_19-15.c
deleted file mode 100755
index b0a8b28..0000000
--- a/native/clang/cvs/TSP_func.2022-05-16_19-15.c
+++ /dev/null
@@ -1,464 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-#ifndef _MATH_H
-#include <math.h>
-#endif
-#include <stdlib.h>
-
-#ifndef _LIBC_LIMITS_H_
-#include <limits.h>
-#endif
-
-
-#define TRUE 1
-#define FALSE 0
-#define TSP_DIV_BY_ZERO "divide by zero"
-#define TSP_DOMAIN_ERROR "domain error"
-
-/* only record the first error */
-#define RAISE_ERROR(m) *rc = TCL_ERROR; if (*exprErrMsg == NULL) *exprErrMsg = m; return 0
-
-#define CHECK_NAN(a) if (isnan(a)) return NAN
-
-/* functions that can raise errors have macros to add rc and exprErrMsg parameters */
-
-#define TSP_func_int_div(a,b) _TSP_func_int_div(rc, &exprErrMsg, (a), (b))
-Tcl_WideInt
-_TSP_func_int_div(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
-    Tcl_WideInt quotient;
-
-    if (divisor == 0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " IntDiv()");
-    }
-    if (dividend == LLONG_MIN && divisor == -1) {
-        /* Avoid integer overflow on (Long.MIN_VALUE / -1) */
-        quotient = LLONG_MIN;
-    } else {
-        quotient = dividend / divisor;
-        /* Round down to a smaller negative number if  */
-        /* there is a remainder and the quotient is    */
-        /* negative or zero and the signs don't match. */
-        if (((quotient < 0) || ((quotient == 0) && (((dividend < 0) && (divisor > 0)) || ((dividend > 0)
-                    && (divisor < 0))))) && ((quotient * divisor) != dividend)) {
-            quotient -= 1;
-        }
-    }
-    return quotient;
-}
-
-
-#define TSP_func_int_mod(a,b) _TSP_func_int_mod(rc, &exprErrMsg, (a), (b))
-Tcl_WideInt
-_TSP_func_int_mod(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
-    Tcl_WideInt remainder = 0;
-    int neg_divisor = 0;
-
-    if (divisor == 0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " IntMod()");
-    }
-
-    if (dividend == LLONG_MIN && divisor == -1) {
-        remainder = 0;
-    } else {
-        if (divisor < 0) {
-            divisor = -divisor;
-            dividend = -dividend;
-            neg_divisor = 1;
-        }
-        remainder = dividend % divisor;
-        if (remainder < 0
-                && !(neg_divisor && (dividend == LLONG_MIN))) {
-            remainder += divisor;
-        }
-    }
-    if ((neg_divisor && (remainder > 0))
-                || (!neg_divisor && (remainder < 0))) {
-        remainder = -remainder;
-    }
-    return remainder;
-}
-
-
-#define TSP_func_double_div(a,b) _TSP_func_double_div(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_double_div(int* rc, char** exprErrMsg, double x, double y) {
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    if (y == 0.0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " DoubleDiv()");
-    } else {
-        return x / y;
-    }
-}
-
-int
-TSP_func_util_strcmp(Tcl_DString* s1, Tcl_DString* s2) {
-    int match;
-    int length1 = Tcl_DStringLength(s1);
-    int length2 = Tcl_DStringLength(s2);
-    length1 = Tcl_NumUtfChars(Tcl_DStringValue(s1), length1);
-    length2 = Tcl_NumUtfChars(Tcl_DStringValue(s2), length2);
-    match = Tcl_UtfNcmp(Tcl_DStringValue(s1), Tcl_DStringValue(s2), (length1 < length2) ? length1 : length2);
-    if (match == 0) {
-        return length1 - length2;
-    } else {
-        return match;
-    }
-}
-
-int
-TSP_func_str_lt(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) < 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_gt(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) > 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_le(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) <= 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_ge(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) >= 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_eq(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) == 0) ? TRUE : FALSE;
-}
-
-int
-TSP_func_str_ne(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) != 0) ? TRUE : FALSE;
-}
-
-
-Tcl_WideInt
-TSP_func_int_abs(Tcl_WideInt i) {
-    if (i < 0) {
-        if (i == LLONG_MIN) {
-            return 0;
-        } else {
-            return i * -1;
-        }
-    } else {
-        return i;
-    }
-}
-
-double
-TSP_func_double_abs(double x) {
-    CHECK_NAN(x);
-    if (x < 0) {
-        return x * -1.0;
-    } else {
-        return x;
-    }
-}
-
-#define TSP_func_acos(a)  _TSP_func_acos(rc, &exprErrMsg, (a))
-double
-_TSP_func_acos(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = acos(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " acos()");
-    }
-    return z;
-}
-
-#define TSP_func_asin(a) _TSP_func_asin(rc, &exprErrMsg, (a))
-double
-_TSP_func_asin(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = asin(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " asin()");
-    }
-    return z;
-}
-
-#define TSP_func_atan(a) _TSP_func_atan(rc, &exprErrMsg, (a))
-double
-_TSP_func_atan(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = atan(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " atan()");
-    }
-    return z;
-}
-
-#define TSP_func_atan2(a,b) _TSP_func_atan2(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_atan2(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = atan2(x, y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " atan2()");
-    }
-    return z;
-}
-
-#define TSP_func_ceil(a)  _TSP_func_ceil(rc, &exprErrMsg, (a))
-double
-_TSP_func_ceil(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = ceil(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " ceil()");
-    }
-    return z;
-}
-
-#define TSP_func_cos(a) _TSP_func_cos(rc, &exprErrMsg, (a))
-double
-_TSP_func_cos(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = cos(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " cos()");
-    }
-    return z;
-}
-
-#define TSP_func_cosh(a) _TSP_func_cosh(rc, &exprErrMsg, (a))
-double
-_TSP_func_cosh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = cosh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " cosh()");
-    }
-    return z;
-}
-
-#define TSP_func_exp(a) _TSP_func_exp(rc, &exprErrMsg, (a))
-double
-_TSP_func_exp(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = exp(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " exp()");
-    }
-    return z;
-}
-
-#define TSP_func_floor(a) _TSP_func_floor(rc, &exprErrMsg, (a))
-double
-_TSP_func_floor(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = floor(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " floor()");
-    }
-    return z;
-}
-
-#define TSP_func_fmod(a) _TSP_func_fmod(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_fmod(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = fmod(x, y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " fmod()");
-    }
-    return z;
-}
-
-#define TSP_func_hypot(a,b) _TSP_func_hypot(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_hypot(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = hypot(x, y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " hypot()");
-    }
-    return z;
-}
-
-#define TSP_func_log(a) _TSP_func_log(rc, &exprErrMsg, (a))
-double
-_TSP_func_log(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = log(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " log()");
-    }
-    return z;
-}
-
-#define TSP_func_log10(a) _TSP_func_log10(rc, &exprErrMsg, (a))
-double
-_TSP_func_log10(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = log(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " log10()");
-    }
-    return z;
-}
-#ifndef max
-#define max(a,b) \
-   ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-     _a > _b ? _a : _b; })
-#endif
-#define TSP_func_max(a,b)  _TSP_func_max(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_max(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = max(x,y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " max()");
-    }
-    return z;
-}
-#ifndef min
-#define min(a,b) \
-   ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-     _a <= _b ? _a : _b; })
-#endif
-#define TSP_func_min(a,b)  _TSP_func_min(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_min(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = min(x,y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " min()");
-    }
-    return z;
-}
-
-#define TSP_func_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
-#define TSP_func_double_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = pow(x, y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
-    }
-    return z;
-}
-
-#define TSP_func_int_pow(a,b) _TSP_func_double_int_pow(rc, &exprErrMsg, (a), (b))
-double
-_TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
-    double z;
-    CHECK_NAN(x);
-    z = pow(x, (double) y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
-    }
-    return z;
-}
-
-
-double
-TSP_func_rand() {
-    return rand(); 
-}
-
-double
-TSP_func_round(double x) {
-    return round(x);
-}
-
-#define TSP_func_sin(a) _TSP_func_sin(rc, &exprErrMsg, (a))
-double
-_TSP_func_sin(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sin(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sin()");
-    }
-    return z;
-}
-
-#define TSP_func_sinh(a) _TSP_func_sinh(rc, &exprErrMsg, (a))
-double
-_TSP_func_sinh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sinh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sinh()");
-    }
-    return z;
-}
-
-#define TSP_func_sqrt(a) _TSP_func_sqrt(rc, &exprErrMsg, (a))
-double
-_TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sqrt(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sqrt()");
-    }
-    return z;
-}
-
-double
-TSP_func_int_srand(Tcl_WideInt i) {
-    srand((long) i);
-    return rand();
-}
-
-#define TSP_func_tan(a) _TSP_func_tan(rc, &exprErrMsg, (a))
-double
-_TSP_func_tan(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = tan(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " tan()");
-    }
-    return z;
-}
-
-#define TSP_func_tanh(a) _TSP_func_tanh(rc, &exprErrMsg, (a))
-double
-_TSP_func_tanh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = tanh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " tanh()");
-    }
-    return z;
-}
-
-
-
diff --git a/native/clang/cvs/TSP_func.2022-07-01_14-53.c b/native/clang/cvs/TSP_func.2022-07-01_14-53.c
deleted file mode 100755
index bea2263..0000000
--- a/native/clang/cvs/TSP_func.2022-07-01_14-53.c
+++ /dev/null
@@ -1,464 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-#ifndef _MATH_H
-#include <math.h>
-#endif
-#include <stdlib.h>
-
-#ifndef _LIBC_LIMITS_H_
-#include <limits.h>
-#endif
-
-
-#define TRUE 1
-#define FALSE 0
-#define TSP_DIV_BY_ZERO "divide by zero"
-#define TSP_DOMAIN_ERROR "domain error"
-
-/* only record the first error */
-#define RAISE_ERROR(m) *rc = TCL_ERROR; if (*exprErrMsg == NULL) *exprErrMsg = m; return 0
-
-#define CHECK_NAN(a) if (isnan(a)) return NAN
-
-/* functions that can raise errors have macros to add rc and exprErrMsg parameters */
-
-#define TSP_func_int_div(a,b) _TSP_func_int_div(rc, &exprErrMsg, (a), (b))
-static inline Tcl_WideInt
-_TSP_func_int_div(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
-    Tcl_WideInt quotient;
-
-    if (divisor == 0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " IntDiv()");
-    }
-    if (dividend == LLONG_MIN && divisor == -1) {
-        /* Avoid integer overflow on (Long.MIN_VALUE / -1) */
-        quotient = LLONG_MIN;
-    } else {
-        quotient = dividend / divisor;
-        /* Round down to a smaller negative number if  */
-        /* there is a remainder and the quotient is    */
-        /* negative or zero and the signs don't match. */
-        if (((quotient < 0) || ((quotient == 0) && (((dividend < 0) && (divisor > 0)) || ((dividend > 0)
-                    && (divisor < 0))))) && ((quotient * divisor) != dividend)) {
-            quotient -= 1;
-        }
-    }
-    return quotient;
-}
-
-
-#define TSP_func_int_mod(a,b) _TSP_func_int_mod(rc, &exprErrMsg, (a), (b))
-static inline Tcl_WideInt
-_TSP_func_int_mod(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
-    Tcl_WideInt remainder = 0;
-    int neg_divisor = 0;
-
-    if (divisor == 0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " IntMod()");
-    }
-
-    if (dividend == LLONG_MIN && divisor == -1) {
-        remainder = 0;
-    } else {
-        if (divisor < 0) {
-            divisor = -divisor;
-            dividend = -dividend;
-            neg_divisor = 1;
-        }
-        remainder = dividend % divisor;
-        if (remainder < 0
-                && !(neg_divisor && (dividend == LLONG_MIN))) {
-            remainder += divisor;
-        }
-    }
-    if ((neg_divisor && (remainder > 0))
-                || (!neg_divisor && (remainder < 0))) {
-        remainder = -remainder;
-    }
-    return remainder;
-}
-
-
-#define TSP_func_double_div(a,b) _TSP_func_double_div(rc, &exprErrMsg, (a), (b))
-static inline double
-_TSP_func_double_div(int* rc, char** exprErrMsg, double x, double y) {
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    if (y == 0.0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " DoubleDiv()");
-    } else {
-        return x / y;
-    }
-}
-
-static inline int
-TSP_func_util_strcmp(Tcl_DString* s1, Tcl_DString* s2) {
-    int match;
-    int length1 = Tcl_DStringLength(s1);
-    int length2 = Tcl_DStringLength(s2);
-    length1 = Tcl_NumUtfChars(Tcl_DStringValue(s1), length1);
-    length2 = Tcl_NumUtfChars(Tcl_DStringValue(s2), length2);
-    match = Tcl_UtfNcmp(Tcl_DStringValue(s1), Tcl_DStringValue(s2), (length1 < length2) ? length1 : length2);
-    if (match == 0) {
-        return length1 - length2;
-    } else {
-        return match;
-    }
-}
-
-static inline int
-TSP_func_str_lt(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) < 0) ? TRUE : FALSE;
-}
-
-static inline int
-TSP_func_str_gt(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) > 0) ? TRUE : FALSE;
-}
-
-static inline int
-TSP_func_str_le(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) <= 0) ? TRUE : FALSE;
-}
-
-static inline int
-TSP_func_str_ge(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) >= 0) ? TRUE : FALSE;
-}
-
-static inline int
-TSP_func_str_eq(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) == 0) ? TRUE : FALSE;
-}
-
-static inline int
-TSP_func_str_ne(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) != 0) ? TRUE : FALSE;
-}
-
-
-static inline Tcl_WideInt
-TSP_func_int_abs(Tcl_WideInt i) {
-    if (i < 0) {
-        if (i == LLONG_MIN) {
-            return 0;
-        } else {
-            return i * -1;
-        }
-    } else {
-        return i;
-    }
-}
-
-static inline double
-TSP_func_double_abs(double x) {
-    CHECK_NAN(x);
-    if (x < 0) {
-        return x * -1.0;
-    } else {
-        return x;
-    }
-}
-
-#define TSP_func_acos(a)  _TSP_func_acos(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_acos(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = acos(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " acos()");
-    }
-    return z;
-}
-
-#define TSP_func_asin(a) _TSP_func_asin(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_asin(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = asin(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " asin()");
-    }
-    return z;
-}
-
-#define TSP_func_atan(a) _TSP_func_atan(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_atan(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = atan(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " atan()");
-    }
-    return z;
-}
-
-#define TSP_func_atan2(a,b) _TSP_func_atan2(rc, &exprErrMsg, (a), (b))
-static inline double
-_TSP_func_atan2(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = atan2(x, y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " atan2()");
-    }
-    return z;
-}
-
-#define TSP_func_ceil(a)  _TSP_func_ceil(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_ceil(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = ceil(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " ceil()");
-    }
-    return z;
-}
-
-#define TSP_func_cos(a) _TSP_func_cos(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_cos(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = cos(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " cos()");
-    }
-    return z;
-}
-
-#define TSP_func_cosh(a) _TSP_func_cosh(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_cosh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = cosh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " cosh()");
-    }
-    return z;
-}
-
-#define TSP_func_exp(a) _TSP_func_exp(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_exp(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = exp(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " exp()");
-    }
-    return z;
-}
-
-#define TSP_func_floor(a) _TSP_func_floor(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_floor(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = floor(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " floor()");
-    }
-    return z;
-}
-
-#define TSP_func_fmod(a) _TSP_func_fmod(rc, &exprErrMsg, (a), (b))
-static inline double
-_TSP_func_fmod(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = fmod(x, y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " fmod()");
-    }
-    return z;
-}
-
-#define TSP_func_hypot(a,b) _TSP_func_hypot(rc, &exprErrMsg, (a), (b))
-static inline double
-_TSP_func_hypot(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = hypot(x, y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " hypot()");
-    }
-    return z;
-}
-
-#define TSP_func_log(a) _TSP_func_log(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_log(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = log(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " log()");
-    }
-    return z;
-}
-
-#define TSP_func_log10(a) _TSP_func_log10(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_log10(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = log(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " log10()");
-    }
-    return z;
-}
-#ifndef max
-#define max(a,b) \
-   ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-     _a > _b ? _a : _b; })
-#endif
-#define TSP_func_max(a,b)  _TSP_func_max(rc, &exprErrMsg, (a), (b))
-static inline double
-_TSP_func_max(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = max(x,y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " max()");
-    }
-    return z;
-}
-#ifndef min
-#define min(a,b) \
-   ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-     _a <= _b ? _a : _b; })
-#endif
-#define TSP_func_min(a,b)  _TSP_func_min(rc, &exprErrMsg, (a), (b))
-static inline double
-_TSP_func_min(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = min(x,y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " min()");
-    }
-    return z;
-}
-
-#define TSP_func_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
-#define TSP_func_double_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
-static inline double
-_TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = pow(x, y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
-    }
-    return z;
-}
-
-#define TSP_func_int_pow(a,b) _TSP_func_double_int_pow(rc, &exprErrMsg, (a), (b))
-static inline double
-_TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
-    double z;
-    CHECK_NAN(x);
-    z = pow(x, (double) y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
-    }
-    return z;
-}
-
-
-static inline double
-TSP_func_rand() {
-    return rand(); 
-}
-
-static inline double
-TSP_func_round(double x) {
-    return round(x);
-}
-
-#define TSP_func_sin(a) _TSP_func_sin(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_sin(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sin(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sin()");
-    }
-    return z;
-}
-
-#define TSP_func_sinh(a) _TSP_func_sinh(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_sinh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sinh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sinh()");
-    }
-    return z;
-}
-
-#define TSP_func_sqrt(a) _TSP_func_sqrt(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sqrt(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sqrt()");
-    }
-    return z;
-}
-
-static inline double
-TSP_func_int_srand(Tcl_WideInt i) {
-    srand((long) i);
-    return rand();
-}
-
-#define TSP_func_tan(a) _TSP_func_tan(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_tan(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = tan(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " tan()");
-    }
-    return z;
-}
-
-#define TSP_func_tanh(a) _TSP_func_tanh(rc, &exprErrMsg, (a))
-static inline double
-_TSP_func_tanh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = tanh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " tanh()");
-    }
-    return z;
-}
-
-
-
diff --git a/native/clang/cvs/TSP_func.2022-07-01_16-24.c b/native/clang/cvs/TSP_func.2022-07-01_16-24.c
deleted file mode 100755
index fc9366c..0000000
--- a/native/clang/cvs/TSP_func.2022-07-01_16-24.c
+++ /dev/null
@@ -1,464 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-#ifndef _MATH_H
-#include <math.h>
-#endif
-#include <stdlib.h>
-
-#ifndef _LIBC_LIMITS_H_
-#include <limits.h>
-#endif
-
-
-#define TRUE 1
-#define FALSE 0
-#define TSP_DIV_BY_ZERO "divide by zero"
-#define TSP_DOMAIN_ERROR "domain error"
-
-/* only record the first error */
-#define RAISE_ERROR(m) *rc = TCL_ERROR; if (*exprErrMsg == NULL) *exprErrMsg = m; return 0
-
-#define CHECK_NAN(a) if (isnan(a)) return NAN
-
-/* functions that can raise errors have macros to add rc and exprErrMsg parameters */
-
-#define TSP_func_int_div(a,b) _TSP_func_int_div(rc, &exprErrMsg, (a), (b))
-TSP_REMOVABLE Tcl_WideInt
-_TSP_func_int_div(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
-    Tcl_WideInt quotient;
-
-    if (divisor == 0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " IntDiv()");
-    }
-    if (dividend == LLONG_MIN && divisor == -1) {
-        /* Avoid integer overflow on (Long.MIN_VALUE / -1) */
-        quotient = LLONG_MIN;
-    } else {
-        quotient = dividend / divisor;
-        /* Round down to a smaller negative number if  */
-        /* there is a remainder and the quotient is    */
-        /* negative or zero and the signs don't match. */
-        if (((quotient < 0) || ((quotient == 0) && (((dividend < 0) && (divisor > 0)) || ((dividend > 0)
-                    && (divisor < 0))))) && ((quotient * divisor) != dividend)) {
-            quotient -= 1;
-        }
-    }
-    return quotient;
-}
-
-
-#define TSP_func_int_mod(a,b) _TSP_func_int_mod(rc, &exprErrMsg, (a), (b))
-TSP_REMOVABLE Tcl_WideInt
-_TSP_func_int_mod(int* rc, char** exprErrMsg, Tcl_WideInt dividend, Tcl_WideInt divisor) {
-    Tcl_WideInt remainder = 0;
-    int neg_divisor = 0;
-
-    if (divisor == 0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " IntMod()");
-    }
-
-    if (dividend == LLONG_MIN && divisor == -1) {
-        remainder = 0;
-    } else {
-        if (divisor < 0) {
-            divisor = -divisor;
-            dividend = -dividend;
-            neg_divisor = 1;
-        }
-        remainder = dividend % divisor;
-        if (remainder < 0
-                && !(neg_divisor && (dividend == LLONG_MIN))) {
-            remainder += divisor;
-        }
-    }
-    if ((neg_divisor && (remainder > 0))
-                || (!neg_divisor && (remainder < 0))) {
-        remainder = -remainder;
-    }
-    return remainder;
-}
-
-
-#define TSP_func_double_div(a,b) _TSP_func_double_div(rc, &exprErrMsg, (a), (b))
-TSP_REMOVABLE double
-_TSP_func_double_div(int* rc, char** exprErrMsg, double x, double y) {
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    if (y == 0.0) {
-        RAISE_ERROR(TSP_DIV_BY_ZERO " DoubleDiv()");
-    } else {
-        return x / y;
-    }
-}
-
-TSP_REMOVABLE int
-TSP_func_util_strcmp(Tcl_DString* s1, Tcl_DString* s2) {
-    int match;
-    int length1 = Tcl_DStringLength(s1);
-    int length2 = Tcl_DStringLength(s2);
-    length1 = Tcl_NumUtfChars(Tcl_DStringValue(s1), length1);
-    length2 = Tcl_NumUtfChars(Tcl_DStringValue(s2), length2);
-    match = Tcl_UtfNcmp(Tcl_DStringValue(s1), Tcl_DStringValue(s2), (length1 < length2) ? length1 : length2);
-    if (match == 0) {
-        return length1 - length2;
-    } else {
-        return match;
-    }
-}
-
-TSP_REMOVABLE int
-TSP_func_str_lt(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) < 0) ? TRUE : FALSE;
-}
-
-TSP_REMOVABLE int
-TSP_func_str_gt(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) > 0) ? TRUE : FALSE;
-}
-
-TSP_REMOVABLE int
-TSP_func_str_le(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) <= 0) ? TRUE : FALSE;
-}
-
-TSP_REMOVABLE int
-TSP_func_str_ge(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) >= 0) ? TRUE : FALSE;
-}
-
-TSP_REMOVABLE int
-TSP_func_str_eq(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) == 0) ? TRUE : FALSE;
-}
-
-TSP_REMOVABLE int
-TSP_func_str_ne(Tcl_DString* s1, Tcl_DString* s2) {
-    return (TSP_func_util_strcmp(s1, s2) != 0) ? TRUE : FALSE;
-}
-
-
-TSP_REMOVABLE Tcl_WideInt
-TSP_func_int_abs(Tcl_WideInt i) {
-    if (i < 0) {
-        if (i == LLONG_MIN) {
-            return 0;
-        } else {
-            return i * -1;
-        }
-    } else {
-        return i;
-    }
-}
-
-TSP_REMOVABLE double
-TSP_func_double_abs(double x) {
-    CHECK_NAN(x);
-    if (x < 0) {
-        return x * -1.0;
-    } else {
-        return x;
-    }
-}
-
-#define TSP_func_acos(a)  _TSP_func_acos(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_acos(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = acos(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " acos()");
-    }
-    return z;
-}
-
-#define TSP_func_asin(a) _TSP_func_asin(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_asin(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = asin(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " asin()");
-    }
-    return z;
-}
-
-#define TSP_func_atan(a) _TSP_func_atan(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_atan(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = atan(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " atan()");
-    }
-    return z;
-}
-
-#define TSP_func_atan2(a,b) _TSP_func_atan2(rc, &exprErrMsg, (a), (b))
-TSP_REMOVABLE double
-_TSP_func_atan2(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = atan2(x, y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " atan2()");
-    }
-    return z;
-}
-
-#define TSP_func_ceil(a)  _TSP_func_ceil(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_ceil(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = ceil(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " ceil()");
-    }
-    return z;
-}
-
-#define TSP_func_cos(a) _TSP_func_cos(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_cos(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = cos(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " cos()");
-    }
-    return z;
-}
-
-#define TSP_func_cosh(a) _TSP_func_cosh(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_cosh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = cosh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " cosh()");
-    }
-    return z;
-}
-
-#define TSP_func_exp(a) _TSP_func_exp(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_exp(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = exp(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " exp()");
-    }
-    return z;
-}
-
-#define TSP_func_floor(a) _TSP_func_floor(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_floor(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = floor(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " floor()");
-    }
-    return z;
-}
-
-#define TSP_func_fmod(a) _TSP_func_fmod(rc, &exprErrMsg, (a), (b))
-TSP_REMOVABLE double
-_TSP_func_fmod(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = fmod(x, y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " fmod()");
-    }
-    return z;
-}
-
-#define TSP_func_hypot(a,b) _TSP_func_hypot(rc, &exprErrMsg, (a), (b))
-TSP_REMOVABLE double
-_TSP_func_hypot(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = hypot(x, y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " hypot()");
-    }
-    return z;
-}
-
-#define TSP_func_log(a) _TSP_func_log(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_log(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = log(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " log()");
-    }
-    return z;
-}
-
-#define TSP_func_log10(a) _TSP_func_log10(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_log10(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = log(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " log10()");
-    }
-    return z;
-}
-#ifndef max
-#define max(a,b) \
-   ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-     _a > _b ? _a : _b; })
-#endif
-#define TSP_func_max(a,b)  _TSP_func_max(rc, &exprErrMsg, (a), (b))
-TSP_REMOVABLE double
-_TSP_func_max(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = max(x,y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " max()");
-    }
-    return z;
-}
-#ifndef min
-#define min(a,b) \
-   ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-     _a <= _b ? _a : _b; })
-#endif
-#define TSP_func_min(a,b)  _TSP_func_min(rc, &exprErrMsg, (a), (b))
-TSP_REMOVABLE double
-_TSP_func_min(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = min(x,y);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " min()");
-    }
-    return z;
-}
-
-#define TSP_func_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
-#define TSP_func_double_pow(a,b) _TSP_func_double_pow(rc, &exprErrMsg, (a), (b))
-TSP_REMOVABLE double
-_TSP_func_double_pow(int* rc, char** exprErrMsg, double x, double y) {
-    double z;
-    CHECK_NAN(x);
-    CHECK_NAN(y);
-    z = pow(x, y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
-    }
-    return z;
-}
-
-#define TSP_func_int_pow(a,b) _TSP_func_double_int_pow(rc, &exprErrMsg, (a), (b))
-TSP_REMOVABLE double
-_TSP_func_double_int_pow(int* rc, char** exprErrMsg, double x, Tcl_WideInt y) {
-    double z;
-    CHECK_NAN(x);
-    z = pow(x, (double) y);
-    if (isnan(z) || z == HUGE_VAL) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " pow()");
-    }
-    return z;
-}
-
-
-TSP_REMOVABLE double
-TSP_func_rand() {
-    return rand(); 
-}
-
-TSP_REMOVABLE double
-TSP_func_round(double x) {
-    return round(x);
-}
-
-#define TSP_func_sin(a) _TSP_func_sin(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_sin(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sin(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sin()");
-    }
-    return z;
-}
-
-#define TSP_func_sinh(a) _TSP_func_sinh(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_sinh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sinh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sinh()");
-    }
-    return z;
-}
-
-#define TSP_func_sqrt(a) _TSP_func_sqrt(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_sqrt(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = sqrt(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " sqrt()");
-    }
-    return z;
-}
-
-TSP_REMOVABLE double
-TSP_func_int_srand(Tcl_WideInt i) {
-    srand((long) i);
-    return rand();
-}
-
-#define TSP_func_tan(a) _TSP_func_tan(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_tan(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = tan(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " tan()");
-    }
-    return z;
-}
-
-#define TSP_func_tanh(a) _TSP_func_tanh(rc, &exprErrMsg, (a))
-TSP_REMOVABLE double
-_TSP_func_tanh(int* rc, char** exprErrMsg, double x) {
-    double z;
-    CHECK_NAN(x);
-    z = tanh(x);
-    if (isnan(z)) {
-        RAISE_ERROR(TSP_DOMAIN_ERROR " tanh()");
-    }
-    return z;
-}
-
-
-
diff --git a/native/clang/cvs/TSP_util.2015-07-28_21-19.c b/native/clang/cvs/TSP_util.2015-07-28_21-19.c
deleted file mode 100755
index 3d81eda..0000000
--- a/native/clang/cvs/TSP_util.2015-07-28_21-19.c
+++ /dev/null
@@ -1,304 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-
-/*********************************************************************************************/
-/* convert to an int from a string */
-int
-TSP_Util_lang_convert_int_string(Tcl_Interp* interp, Tcl_DString* sourceVarName, Tcl_WideInt* targetVarName) {
-    int rc;
-    Tcl_Obj* obj = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
-    Tcl_IncrRefCount(obj);
-    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
-    Tcl_DecrRefCount(obj);
-    return rc;
-}
-
-
-/*********************************************************************************************/
-/* convert to an int from a string const */
-int
-TSP_Util_lang_convert_int_string_const(Tcl_Interp* interp, char* sourceVarName, Tcl_WideInt* targetVarName) {
-    int rc;
-    Tcl_Obj* obj = Tcl_NewStringObj(sourceVarName, -1);
-    Tcl_IncrRefCount(obj);
-    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
-    Tcl_DecrRefCount(obj);
-    return rc;
-}
-
-
-/*********************************************************************************************/
-/* convert to a string from an int */
-Tcl_DString*
-TSP_Util_lang_convert_string_int(Tcl_Interp* interp, Tcl_DString* targetVarName, Tcl_WideInt sourceVarName) {
-    char str[500];
-    char *format = "%" TCL_LL_MODIFIER "d";
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    sprintf(str, format, sourceVarName);
-    Tcl_DStringAppend(targetVarName, str, -1);
-    return targetVarName;
-}
-
-
-
-/*********************************************************************************************/
-/* convert to a string from a double */
-Tcl_DString*
-TSP_Util_lang_convert_string_double(Tcl_Interp* interp, Tcl_DString* targetVarName, double sourceVarName) {
-    char str[500];
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    Tcl_PrintDouble(interp, sourceVarName, str);
-    Tcl_DStringAppend(targetVarName, str, -1);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* convert to a string from a var */
-Tcl_DString*
-TSP_Util_lang_convert_string_var(Tcl_DString* targetVarName, Tcl_Obj* sourceVarName) {
-    char* str;
-    int len;
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    str = Tcl_GetStringFromObj(sourceVarName, &len);
-    Tcl_DStringAppend(targetVarName, str, len);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* get a string from an int */
-/* string must be used immediately */
-Tcl_DString*
-TSP_Util_lang_get_string_int(Tcl_WideInt sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    Tcl_DString* dsPtr;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    dsPtr = &ds;
-    dsPtr = TSP_Util_lang_convert_string_int(NULL, dsPtr, sourceVarName);
-    return dsPtr;
-}
-
-
-/*********************************************************************************************/
-/* get a string from an double */
-/* string must be used immediately */
-Tcl_DString*
-TSP_Util_lang_get_string_double(double sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    TSP_Util_lang_convert_string_double(NULL, &ds, sourceVarName);
-    return &ds;
-}
-
-/*********************************************************************************************/
-/* get a string from a var */
-/* string must be used immediately */
-Tcl_DString*
-TSP_Util_lang_get_string_var(Tcl_Obj* sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    int len;
-    char* str;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    str = Tcl_GetStringFromObj(sourceVarName, &len);
-    Tcl_DStringAppend(&ds, str, len);
-    return &ds;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from a boolean */
-Tcl_Obj*
-TSP_Util_lang_assign_var_boolean(Tcl_Obj* targetVarName, int sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewBooleanObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an int */
-Tcl_Obj*
-TSP_Util_lang_assign_var_int(Tcl_Obj* targetVarName, Tcl_WideInt sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewWideIntObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an double */
-Tcl_Obj*
-TSP_Util_lang_assign_var_double(Tcl_Obj* targetVarName, double sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewDoubleObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an string */
-Tcl_Obj*
-TSP_Util_lang_assign_var_string(Tcl_Obj* targetVarName, Tcl_DString* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an string const */
-Tcl_Obj*
-TSP_Util_lang_assign_var_string_const(Tcl_Obj* targetVarName, char* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewStringObj(sourceVarName, -1);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from a var */
-Tcl_Obj*
-TSP_Util_lang_assign_var_var(Tcl_Obj* targetVarName, Tcl_Obj* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-
-    /* targetVarName = Tcl_DuplicateObj(sourceVarName);  */
-    targetVarName = sourceVarName;
-
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign an array & element from a var */
-int
-TSP_Util_lang_assign_array_var(Tcl_Interp* interp, Tcl_Obj* targetArrayVar, Tcl_Obj* targetIdxVar, Tcl_Obj* var) {
-    Tcl_Obj* obj;
-    obj = Tcl_ObjSetVar2(interp, targetArrayVar, targetIdxVar, var, TCL_LEAVE_ERR_MSG);
-    if (obj == NULL) {
-        return TCL_ERROR;
-    } else {
-        return TCL_OK;
-    }
-}
-
-
-/*********************************************************************************************/
-/* compare two Tcl_DStrings */
-int
-TSP_Util_string_compare(Tcl_DString* s1, Tcl_DString* s2) {
-    char* string2;
-    int length2;
-
-    return TSP_Util_string_compare_const(s1, Tcl_DStringValue(s2), Tcl_DStringLength(s2));
-}
-
-/*********************************************************************************************/
-/* compare a Tcl_DString to a const string. use negative length to find first null in string2 */
-int
-TSP_Util_string_compare_const(Tcl_DString* s1, char* string2, int length2) {
-    char* string1;
-    int length1;
-    int length;
-    int match;
-
-    string1 = Tcl_DStringValue(s1);
-    length1 = Tcl_DStringLength(s1);
-
-    length1 = Tcl_NumUtfChars(string1, length1);
-    length2 = Tcl_NumUtfChars(string2, length2);
-    
-    length = (length1 < length2) ? length1 : length2;
-    match = Tcl_UtfNcmp(string1, string2, (unsigned) length);
-    if (match == 0) {
-        match = length1 - length2;
-    }
-    return match;
-}
-
-
-/*********************************************************************************************/
-/* create a constant string obj                                                              */
-Tcl_Obj*
-TSP_Util_const_string(char* str) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewStringObj(str, -1);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-/*********************************************************************************************/
-/* create a constant wide int obj                                                            */
-Tcl_Obj*
-TSP_Util_const_int(Tcl_WideInt i) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewWideIntObj(i);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-/*********************************************************************************************/
-/* create a constant double obj                                                              */
-Tcl_Obj*
-TSP_Util_const_double(double d) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewDoubleObj(d);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-
-
diff --git a/native/clang/cvs/TSP_util.2022-04-24_23-21.c b/native/clang/cvs/TSP_util.2022-04-24_23-21.c
deleted file mode 100755
index 6f910f7..0000000
--- a/native/clang/cvs/TSP_util.2022-04-24_23-21.c
+++ /dev/null
@@ -1,304 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-
-/*********************************************************************************************/
-/* convert to an int from a string */
-int
-TSP_Util_lang_convert_int_string(Tcl_Interp* interp, Tcl_DString* sourceVarName, Tcl_WideInt* targetVarName) {
-    int rc;
-    Tcl_Obj* obj = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
-    Tcl_IncrRefCount(obj);
-    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
-    Tcl_DecrRefCount(obj);
-    return rc;
-}
-
-
-/*********************************************************************************************/
-/* convert to an int from a string const */
-int
-TSP_Util_lang_convert_int_string_const(Tcl_Interp* interp, char* sourceVarName, Tcl_WideInt* targetVarName) {
-    int rc;
-    Tcl_Obj* obj = Tcl_NewStringObj(sourceVarName, -1);
-    Tcl_IncrRefCount(obj);
-    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
-    Tcl_DecrRefCount(obj);
-    return rc;
-}
-
-
-/*********************************************************************************************/
-/* convert to a string from an int */
-Tcl_DString*
-TSP_Util_lang_convert_string_int(Tcl_Interp* interp, Tcl_DString* targetVarName, Tcl_WideInt sourceVarName) {
-    char str[500];
-    char *format = "%" TCL_LL_MODIFIER "d";
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    sprintf(str, format, sourceVarName);
-    Tcl_DStringAppend(targetVarName, str, -1);
-    return targetVarName;
-}
-
-
-
-/*********************************************************************************************/
-/* convert to a string from a double */
-Tcl_DString*
-TSP_Util_lang_convert_string_double(Tcl_Interp* interp, Tcl_DString* targetVarName, double sourceVarName) {
-    char str[500];
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    Tcl_PrintDouble(interp, sourceVarName, str);
-    Tcl_DStringAppend(targetVarName, str, -1);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* convert to a string from a var */
-Tcl_DString*
-TSP_Util_lang_convert_string_var(Tcl_DString* targetVarName, Tcl_Obj* sourceVarName) {
-    char* str;
-    int len;
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    str = Tcl_GetStringFromObj(sourceVarName, &len);
-    Tcl_DStringAppend(targetVarName, str, len);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* get a string from an int */
-/* string must be used immediately */
-Tcl_DString*
-TSP_Util_lang_get_string_int(Tcl_WideInt sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    Tcl_DString* dsPtr;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    dsPtr = &ds;
-    dsPtr = TSP_Util_lang_convert_string_int(NULL, dsPtr, sourceVarName);
-    return dsPtr;
-}
-
-
-/*********************************************************************************************/
-/* get a string from an double */
-/* string must be used immediately */
-Tcl_DString*
-TSP_Util_lang_get_string_double(double sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    TSP_Util_lang_convert_string_double(NULL, &ds, sourceVarName);
-    return &ds;
-}
-
-/*********************************************************************************************/
-/* get a string from a var */
-/* string must be used immediately */
-Tcl_DString*
-TSP_Util_lang_get_string_var(Tcl_Obj* sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    int len;
-    char* str;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    str = Tcl_GetStringFromObj(sourceVarName, &len);
-    Tcl_DStringAppend(&ds, str, len);
-    return &ds;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from a boolean */
-Tcl_Obj*
-TSP_Util_lang_assign_var_boolean(Tcl_Obj* targetVarName, int sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewBooleanObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an int */
-Tcl_Obj*
-TSP_Util_lang_assign_var_int(Tcl_Obj* targetVarName, Tcl_WideInt sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewWideIntObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an double */
-Tcl_Obj*
-TSP_Util_lang_assign_var_double(Tcl_Obj* targetVarName, double sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewDoubleObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an string */
-Tcl_Obj*
-TSP_Util_lang_assign_var_string(Tcl_Obj* targetVarName, Tcl_DString* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an string const */
-Tcl_Obj*
-TSP_Util_lang_assign_var_string_const(Tcl_Obj* targetVarName, char* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewStringObj(sourceVarName, -1);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from a var */
-Tcl_Obj*
-TSP_Util_lang_assign_var_var(Tcl_Obj* targetVarName, Tcl_Obj* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-
-     targetVarName = Tcl_DuplicateObj(sourceVarName);  
-    //targetVarName = sourceVarName;
-
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign an array & element from a var */
-int
-TSP_Util_lang_assign_array_var(Tcl_Interp* interp, Tcl_Obj* targetArrayVar, Tcl_Obj* targetIdxVar, Tcl_Obj* var) {
-    Tcl_Obj* obj;
-    obj = Tcl_ObjSetVar2(interp, targetArrayVar, targetIdxVar, var, TCL_LEAVE_ERR_MSG);
-    if (obj == NULL) {
-        return TCL_ERROR;
-    } else {
-        return TCL_OK;
-    }
-}
-
-/*********************************************************************************************/
-/* compare a Tcl_DString to a const string. use negative length to find first null in string2 */
-int
-TSP_Util_string_compare_const(Tcl_DString* s1, char* string2, int length2) {
-    char* string1;
-    int length1;
-    int length;
-    int match;
-
-    string1 = Tcl_DStringValue(s1);
-    length1 = Tcl_DStringLength(s1);
-
-    length1 = Tcl_NumUtfChars(string1, length1);
-    length2 = Tcl_NumUtfChars(string2, length2);
-    
-    length = (length1 < length2) ? length1 : length2;
-    match = Tcl_UtfNcmp(string1, string2, (unsigned) length);
-    if (match == 0) {
-        match = length1 - length2;
-    }
-    return match;
-}
-
-
-/*********************************************************************************************/
-/* compare two Tcl_DStrings */
-int
-TSP_Util_string_compare(Tcl_DString* s1, Tcl_DString* s2) {
-    char* string2;
-    int length2;
-
-    return TSP_Util_string_compare_const(s1, Tcl_DStringValue(s2), Tcl_DStringLength(s2));
-}
-
-
-/*********************************************************************************************/
-/* create a constant string obj                                                              */
-Tcl_Obj*
-TSP_Util_const_string(char* str) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewStringObj(str, -1);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-/*********************************************************************************************/
-/* create a constant wide int obj                                                            */
-Tcl_Obj*
-TSP_Util_const_int(Tcl_WideInt i) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewWideIntObj(i);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-/*********************************************************************************************/
-/* create a constant double obj                                                              */
-Tcl_Obj*
-TSP_Util_const_double(double d) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewDoubleObj(d);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-
-
diff --git a/native/clang/cvs/TSP_util.2022-05-13_12-25.c b/native/clang/cvs/TSP_util.2022-05-13_12-25.c
deleted file mode 100755
index 15c16f9..0000000
--- a/native/clang/cvs/TSP_util.2022-05-13_12-25.c
+++ /dev/null
@@ -1,313 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-
-/*********************************************************************************************/
-/* convert to an int from a string */
-int
-TSP_Util_lang_convert_int_string(Tcl_Interp* interp, Tcl_DString* sourceVarName, Tcl_WideInt* targetVarName) {
-    int rc;
-    Tcl_Obj* obj = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
-    Tcl_IncrRefCount(obj);
-    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
-    Tcl_DecrRefCount(obj);
-    return rc;
-}
-
-
-/*********************************************************************************************/
-/* convert to an int from a string const */
-int
-TSP_Util_lang_convert_int_string_const(Tcl_Interp* interp, char* sourceVarName, Tcl_WideInt* targetVarName) {
-    int rc;
-    Tcl_Obj* obj = Tcl_NewStringObj(sourceVarName, -1);
-    Tcl_IncrRefCount(obj);
-    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
-    Tcl_DecrRefCount(obj);
-    return rc;
-}
-
-
-/*********************************************************************************************/
-/* convert to a string from an int */
-Tcl_DString*
-TSP_Util_lang_convert_string_int(Tcl_Interp* interp, Tcl_DString* targetVarName, Tcl_WideInt sourceVarName) {
-    char str[500];
-    char *format = "%" TCL_LL_MODIFIER "d";
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    sprintf(str, format, sourceVarName);
-    Tcl_DStringAppend(targetVarName, str, -1);
-    return targetVarName;
-}
-
-
-
-/*********************************************************************************************/
-/* convert to a string from a double */
-Tcl_DString*
-TSP_Util_lang_convert_string_double(Tcl_Interp* interp, Tcl_DString* targetVarName, double sourceVarName) {
-    char str[500];
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    Tcl_PrintDouble(interp, sourceVarName, str);
-    Tcl_DStringAppend(targetVarName, str, -1);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* convert to a string from a var */
-Tcl_DString*
-TSP_Util_lang_convert_string_var(Tcl_DString* targetVarName, Tcl_Obj* sourceVarName) {
-    char* str;
-    int len;
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    str = Tcl_GetStringFromObj(sourceVarName, &len);
-    Tcl_DStringAppend(targetVarName, str, len);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* get a string from an int */
-/* string must be used immediately */
-Tcl_DString*
-TSP_Util_lang_get_string_int(Tcl_WideInt sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    Tcl_DString* dsPtr;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    dsPtr = &ds;
-    dsPtr = TSP_Util_lang_convert_string_int(NULL, dsPtr, sourceVarName);
-    return dsPtr;
-}
-
-
-/*********************************************************************************************/
-/* get a string from an double */
-/* string must be used immediately */
-Tcl_DString*
-TSP_Util_lang_get_string_double(double sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    TSP_Util_lang_convert_string_double(NULL, &ds, sourceVarName);
-    return &ds;
-}
-
-/*********************************************************************************************/
-/* get a string from a var */
-/* string must be used immediately */
-Tcl_DString*
-TSP_Util_lang_get_string_var(Tcl_Obj* sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    int len;
-    char* str;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    str = Tcl_GetStringFromObj(sourceVarName, &len);
-    Tcl_DStringAppend(&ds, str, len);
-    return &ds;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from a boolean */
-Tcl_Obj*
-TSP_Util_lang_assign_var_boolean(Tcl_Obj* targetVarName, int sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewBooleanObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an int */
-Tcl_Obj*
-TSP_Util_lang_assign_var_int(Tcl_Obj* targetVarName, Tcl_WideInt sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewWideIntObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an double */
-Tcl_Obj*
-TSP_Util_lang_assign_var_double(Tcl_Obj* targetVarName, double sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewDoubleObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an string */
-Tcl_Obj*
-TSP_Util_lang_assign_var_string(Tcl_Obj* targetVarName, Tcl_DString* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an string const */
-Tcl_Obj*
-TSP_Util_lang_assign_var_string_const(Tcl_Obj* targetVarName, char* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewStringObj(sourceVarName, -1);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from a var */
-Tcl_Obj*
-TSP_Util_lang_assign_var_var(Tcl_Obj* targetVarName, Tcl_Obj* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-
-     targetVarName = Tcl_DuplicateObj(sourceVarName);  
-    //targetVarName = sourceVarName;
-
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign an array & element from a var */
-int
-TSP_Util_lang_assign_array_var(Tcl_Interp* interp, Tcl_Obj* targetArrayVar, Tcl_Obj* targetIdxVar, Tcl_Obj* var) {
-    Tcl_Obj* obj;
-    obj = Tcl_ObjSetVar2(interp, targetArrayVar, targetIdxVar, var, TCL_LEAVE_ERR_MSG);
-    if (obj == NULL) {
-        return TCL_ERROR;
-    } else {
-        return TCL_OK;
-    }
-}
-
-/*********************************************************************************************/
-/* compare a Tcl_DString to a const string. use negative length to find first null in string2 */
-int
-TSP_Util_string_compare_const(Tcl_DString* s1, char* string2, int length2) {
-    char* string1;
-    int length1;
-    int length;
-    int match;
-
-    string1 = Tcl_DStringValue(s1);
-    length1 = Tcl_DStringLength(s1);
-
-    length1 = Tcl_NumUtfChars(string1, length1);
-    length2 = Tcl_NumUtfChars(string2, length2);
-    
-    length = (length1 < length2) ? length1 : length2;
-    match = Tcl_UtfNcmp(string1, string2, (unsigned) length);
-    if (match == 0) {
-        match = length1 - length2;
-    }
-    return match;
-}
-
-
-/*********************************************************************************************/
-/* compare two Tcl_DStrings */
-int
-TSP_Util_string_compare(Tcl_DString* s1, Tcl_DString* s2) {
-    char* string2;
-    int length2;
-
-    return TSP_Util_string_compare_const(s1, Tcl_DStringValue(s2), Tcl_DStringLength(s2));
-}
-
-
-/* create Dstring from Char in tmpVar */ 
-Tcl_DString* TSP_UTIL_dstring_from_char (char* str, Tcl_DString* tmpvar) {
-    Tcl_DStringSetLength(tmpvar, 0);
-    Tcl_DStringAppend(tmpvar, str, -1);
-    return tmpvar;
-}
-
-
-
-/*********************************************************************************************/
-/* create a constant string obj                                                              */
-Tcl_Obj*
-TSP_Util_const_string(char* str) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewStringObj(str, -1);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-/*********************************************************************************************/
-/* create a constant wide int obj                                                            */
-Tcl_Obj*
-TSP_Util_const_int(Tcl_WideInt i) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewWideIntObj(i);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-/*********************************************************************************************/
-/* create a constant double obj                                                              */
-Tcl_Obj*
-TSP_Util_const_double(double d) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewDoubleObj(d);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-
-
diff --git a/native/clang/cvs/TSP_util.2022-07-01_14-55.c b/native/clang/cvs/TSP_util.2022-07-01_14-55.c
deleted file mode 100755
index 2d440cf..0000000
--- a/native/clang/cvs/TSP_util.2022-07-01_14-55.c
+++ /dev/null
@@ -1,313 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-
-/*********************************************************************************************/
-/* convert to an int from a string */
-static inline int
-TSP_Util_lang_convert_int_string(Tcl_Interp* interp, Tcl_DString* sourceVarName, Tcl_WideInt* targetVarName) {
-    int rc;
-    Tcl_Obj* obj = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
-    Tcl_IncrRefCount(obj);
-    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
-    Tcl_DecrRefCount(obj);
-    return rc;
-}
-
-
-/*********************************************************************************************/
-/* convert to an int from a string const */
-static inline int
-TSP_Util_lang_convert_int_string_const(Tcl_Interp* interp, char* sourceVarName, Tcl_WideInt* targetVarName) {
-    int rc;
-    Tcl_Obj* obj = Tcl_NewStringObj(sourceVarName, -1);
-    Tcl_IncrRefCount(obj);
-    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
-    Tcl_DecrRefCount(obj);
-    return rc;
-}
-
-
-/*********************************************************************************************/
-/* convert to a string from an int */
-static inline Tcl_DString*
-TSP_Util_lang_convert_string_int(Tcl_Interp* interp, Tcl_DString* targetVarName, Tcl_WideInt sourceVarName) {
-    char str[500];
-    char *format = "%" TCL_LL_MODIFIER "d";
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    sprintf(str, format, sourceVarName);
-    Tcl_DStringAppend(targetVarName, str, -1);
-    return targetVarName;
-}
-
-
-
-/*********************************************************************************************/
-/* convert to a string from a double */
-static inline Tcl_DString*
-TSP_Util_lang_convert_string_double(Tcl_Interp* interp, Tcl_DString* targetVarName, double sourceVarName) {
-    char str[500];
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    Tcl_PrintDouble(interp, sourceVarName, str);
-    Tcl_DStringAppend(targetVarName, str, -1);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* convert to a string from a var */
-static inline Tcl_DString*
-TSP_Util_lang_convert_string_var(Tcl_DString* targetVarName, Tcl_Obj* sourceVarName) {
-    char* str;
-    int len;
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    str = Tcl_GetStringFromObj(sourceVarName, &len);
-    Tcl_DStringAppend(targetVarName, str, len);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* get a string from an int */
-/* string must be used immediately */
-static inline Tcl_DString*
-TSP_Util_lang_get_string_int(Tcl_WideInt sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    Tcl_DString* dsPtr;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    dsPtr = &ds;
-    dsPtr = TSP_Util_lang_convert_string_int(NULL, dsPtr, sourceVarName);
-    return dsPtr;
-}
-
-
-/*********************************************************************************************/
-/* get a string from an double */
-/* string must be used immediately */
-static inline Tcl_DString*
-TSP_Util_lang_get_string_double(double sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    TSP_Util_lang_convert_string_double(NULL, &ds, sourceVarName);
-    return &ds;
-}
-
-/*********************************************************************************************/
-/* get a string from a var */
-/* string must be used immediately */
-static inline Tcl_DString*
-TSP_Util_lang_get_string_var(Tcl_Obj* sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    int len;
-    char* str;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    str = Tcl_GetStringFromObj(sourceVarName, &len);
-    Tcl_DStringAppend(&ds, str, len);
-    return &ds;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from a boolean */
-static inline Tcl_Obj*
-TSP_Util_lang_assign_var_boolean(Tcl_Obj* targetVarName, int sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewBooleanObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an int */
-static inline Tcl_Obj*
-TSP_Util_lang_assign_var_int(Tcl_Obj* targetVarName, Tcl_WideInt sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewWideIntObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an double */
-static inline Tcl_Obj*
-TSP_Util_lang_assign_var_double(Tcl_Obj* targetVarName, double sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewDoubleObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an string */
-static inline Tcl_Obj*
-TSP_Util_lang_assign_var_string(Tcl_Obj* targetVarName, Tcl_DString* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an string const */
-static inline Tcl_Obj*
-TSP_Util_lang_assign_var_string_const(Tcl_Obj* targetVarName, char* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewStringObj(sourceVarName, -1);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from a var */
-static inline Tcl_Obj*
-TSP_Util_lang_assign_var_var(Tcl_Obj* targetVarName, Tcl_Obj* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-
-     targetVarName = Tcl_DuplicateObj(sourceVarName);  
-    //targetVarName = sourceVarName;
-
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign an array & element from a var */
-static inline int
-TSP_Util_lang_assign_array_var(Tcl_Interp* interp, Tcl_Obj* targetArrayVar, Tcl_Obj* targetIdxVar, Tcl_Obj* var) {
-    Tcl_Obj* obj;
-    obj = Tcl_ObjSetVar2(interp, targetArrayVar, targetIdxVar, var, TCL_LEAVE_ERR_MSG);
-    if (obj == NULL) {
-        return TCL_ERROR;
-    } else {
-        return TCL_OK;
-    }
-}
-
-/*********************************************************************************************/
-/* compare a Tcl_DString to a const string. use negative length to find first null in string2 */
-static inline int
-TSP_Util_string_compare_const(Tcl_DString* s1, char* string2, int length2) {
-    char* string1;
-    int length1;
-    int length;
-    int match;
-
-    string1 = Tcl_DStringValue(s1);
-    length1 = Tcl_DStringLength(s1);
-
-    length1 = Tcl_NumUtfChars(string1, length1);
-    length2 = Tcl_NumUtfChars(string2, length2);
-    
-    length = (length1 < length2) ? length1 : length2;
-    match = Tcl_UtfNcmp(string1, string2, (unsigned) length);
-    if (match == 0) {
-        match = length1 - length2;
-    }
-    return match;
-}
-
-
-/*********************************************************************************************/
-/* compare two Tcl_DStrings */
-static inline int
-TSP_Util_string_compare(Tcl_DString* s1, Tcl_DString* s2) {
-    char* string2;
-    int length2;
-
-    return TSP_Util_string_compare_const(s1, Tcl_DStringValue(s2), Tcl_DStringLength(s2));
-}
-
-
-/* create Dstring from Char in tmpVar */ 
-Tcl_DString* TSP_UTIL_dstring_from_char (char* str, Tcl_DString* tmpvar) {
-    Tcl_DStringSetLength(tmpvar, 0);
-    Tcl_DStringAppend(tmpvar, str, -1);
-    return tmpvar;
-}
-
-
-
-/*********************************************************************************************/
-/* create a constant string obj                                                              */
-static inline Tcl_Obj*
-TSP_Util_const_string(char* str) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewStringObj(str, -1);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-/*********************************************************************************************/
-/* create a constant wide int obj                                                            */
-static inline Tcl_Obj*
-TSP_Util_const_int(Tcl_WideInt i) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewWideIntObj(i);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-/*********************************************************************************************/
-/* create a constant double obj                                                              */
-static inline Tcl_Obj*
-TSP_Util_const_double(double d) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewDoubleObj(d);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-
-
diff --git a/native/clang/cvs/TSP_util.2022-07-01_16-24.c b/native/clang/cvs/TSP_util.2022-07-01_16-24.c
deleted file mode 100755
index a17879f..0000000
--- a/native/clang/cvs/TSP_util.2022-07-01_16-24.c
+++ /dev/null
@@ -1,313 +0,0 @@
-#ifndef _TCL
-#include <tcl.h>
-#endif
-
-
-/*********************************************************************************************/
-/* convert to an int from a string */
-TSP_REMOVABLE int
-TSP_Util_lang_convert_int_string(Tcl_Interp* interp, Tcl_DString* sourceVarName, Tcl_WideInt* targetVarName) {
-    int rc;
-    Tcl_Obj* obj = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
-    Tcl_IncrRefCount(obj);
-    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
-    Tcl_DecrRefCount(obj);
-    return rc;
-}
-
-
-/*********************************************************************************************/
-/* convert to an int from a string const */
-TSP_REMOVABLE int
-TSP_Util_lang_convert_int_string_const(Tcl_Interp* interp, char* sourceVarName, Tcl_WideInt* targetVarName) {
-    int rc;
-    Tcl_Obj* obj = Tcl_NewStringObj(sourceVarName, -1);
-    Tcl_IncrRefCount(obj);
-    rc = Tcl_GetWideIntFromObj(interp, obj, targetVarName);
-    Tcl_DecrRefCount(obj);
-    return rc;
-}
-
-
-/*********************************************************************************************/
-/* convert to a string from an int */
-TSP_REMOVABLE Tcl_DString*
-TSP_Util_lang_convert_string_int(Tcl_Interp* interp, Tcl_DString* targetVarName, Tcl_WideInt sourceVarName) {
-    char str[500];
-    char *format = "%" TCL_LL_MODIFIER "d";
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    sprintf(str, format, sourceVarName);
-    Tcl_DStringAppend(targetVarName, str, -1);
-    return targetVarName;
-}
-
-
-
-/*********************************************************************************************/
-/* convert to a string from a double */
-TSP_REMOVABLE Tcl_DString*
-TSP_Util_lang_convert_string_double(Tcl_Interp* interp, Tcl_DString* targetVarName, double sourceVarName) {
-    char str[500];
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    Tcl_PrintDouble(interp, sourceVarName, str);
-    Tcl_DStringAppend(targetVarName, str, -1);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* convert to a string from a var */
-TSP_REMOVABLE Tcl_DString*
-TSP_Util_lang_convert_string_var(Tcl_DString* targetVarName, Tcl_Obj* sourceVarName) {
-    char* str;
-    int len;
-    if (targetVarName != NULL) {
-        Tcl_DStringSetLength(targetVarName, 0);
-    } else {
-        targetVarName = (Tcl_DString*) ckalloc(sizeof(Tcl_DString));;
-        Tcl_DStringInit(targetVarName);
-    }
-    str = Tcl_GetStringFromObj(sourceVarName, &len);
-    Tcl_DStringAppend(targetVarName, str, len);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* get a string from an int */
-/* string must be used immediately */
-TSP_REMOVABLE Tcl_DString*
-TSP_Util_lang_get_string_int(Tcl_WideInt sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    Tcl_DString* dsPtr;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    dsPtr = &ds;
-    dsPtr = TSP_Util_lang_convert_string_int(NULL, dsPtr, sourceVarName);
-    return dsPtr;
-}
-
-
-/*********************************************************************************************/
-/* get a string from an double */
-/* string must be used immediately */
-TSP_REMOVABLE Tcl_DString*
-TSP_Util_lang_get_string_double(double sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    TSP_Util_lang_convert_string_double(NULL, &ds, sourceVarName);
-    return &ds;
-}
-
-/*********************************************************************************************/
-/* get a string from a var */
-/* string must be used immediately */
-TSP_REMOVABLE Tcl_DString*
-TSP_Util_lang_get_string_var(Tcl_Obj* sourceVarName) {
-    static int doInit = 1;
-    static Tcl_DString ds;
-    int len;
-    char* str;
-    if (doInit) {
-        Tcl_DStringInit(&ds);
-        doInit = 0;
-    } else {
-        Tcl_DStringSetLength(&ds, 0);
-    }
-    str = Tcl_GetStringFromObj(sourceVarName, &len);
-    Tcl_DStringAppend(&ds, str, len);
-    return &ds;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from a boolean */
-TSP_REMOVABLE Tcl_Obj*
-TSP_Util_lang_assign_var_boolean(Tcl_Obj* targetVarName, int sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewBooleanObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an int */
-TSP_REMOVABLE Tcl_Obj*
-TSP_Util_lang_assign_var_int(Tcl_Obj* targetVarName, Tcl_WideInt sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewWideIntObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an double */
-TSP_REMOVABLE Tcl_Obj*
-TSP_Util_lang_assign_var_double(Tcl_Obj* targetVarName, double sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewDoubleObj(sourceVarName);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an string */
-TSP_REMOVABLE Tcl_Obj*
-TSP_Util_lang_assign_var_string(Tcl_Obj* targetVarName, Tcl_DString* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewStringObj(Tcl_DStringValue(sourceVarName), Tcl_DStringLength(sourceVarName));
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from an string const */
-TSP_REMOVABLE Tcl_Obj*
-TSP_Util_lang_assign_var_string_const(Tcl_Obj* targetVarName, char* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-    targetVarName = Tcl_NewStringObj(sourceVarName, -1);
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign a var from a var */
-TSP_REMOVABLE Tcl_Obj*
-TSP_Util_lang_assign_var_var(Tcl_Obj* targetVarName, Tcl_Obj* sourceVarName) {
-    if (targetVarName != NULL) {
-        Tcl_DecrRefCount(targetVarName);
-    }
-
-     targetVarName = Tcl_DuplicateObj(sourceVarName);  
-    //targetVarName = sourceVarName;
-
-    Tcl_IncrRefCount(targetVarName);
-    return targetVarName;
-}
-
-
-/*********************************************************************************************/
-/* assign an array & element from a var */
-TSP_REMOVABLE int
-TSP_Util_lang_assign_array_var(Tcl_Interp* interp, Tcl_Obj* targetArrayVar, Tcl_Obj* targetIdxVar, Tcl_Obj* var) {
-    Tcl_Obj* obj;
-    obj = Tcl_ObjSetVar2(interp, targetArrayVar, targetIdxVar, var, TCL_LEAVE_ERR_MSG);
-    if (obj == NULL) {
-        return TCL_ERROR;
-    } else {
-        return TCL_OK;
-    }
-}
-
-/*********************************************************************************************/
-/* compare a Tcl_DString to a const string. use negative length to find first null in string2 */
-TSP_REMOVABLE int
-TSP_Util_string_compare_const(Tcl_DString* s1, char* string2, int length2) {
-    char* string1;
-    int length1;
-    int length;
-    int match;
-
-    string1 = Tcl_DStringValue(s1);
-    length1 = Tcl_DStringLength(s1);
-
-    length1 = Tcl_NumUtfChars(string1, length1);
-    length2 = Tcl_NumUtfChars(string2, length2);
-    
-    length = (length1 < length2) ? length1 : length2;
-    match = Tcl_UtfNcmp(string1, string2, (unsigned) length);
-    if (match == 0) {
-        match = length1 - length2;
-    }
-    return match;
-}
-
-
-/*********************************************************************************************/
-/* compare two Tcl_DStrings */
-TSP_REMOVABLE int
-TSP_Util_string_compare(Tcl_DString* s1, Tcl_DString* s2) {
-    char* string2;
-    int length2;
-
-    return TSP_Util_string_compare_const(s1, Tcl_DStringValue(s2), Tcl_DStringLength(s2));
-}
-
-
-/* create Dstring from Char in tmpVar */ 
-Tcl_DString* TSP_UTIL_dstring_from_char (char* str, Tcl_DString* tmpvar) {
-    Tcl_DStringSetLength(tmpvar, 0);
-    Tcl_DStringAppend(tmpvar, str, -1);
-    return tmpvar;
-}
-
-
-
-/*********************************************************************************************/
-/* create a constant string obj                                                              */
-TSP_REMOVABLE Tcl_Obj*
-TSP_Util_const_string(char* str) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewStringObj(str, -1);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-/*********************************************************************************************/
-/* create a constant wide int obj                                                            */
-TSP_REMOVABLE Tcl_Obj*
-TSP_Util_const_int(Tcl_WideInt i) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewWideIntObj(i);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-/*********************************************************************************************/
-/* create a constant double obj                                                              */
-TSP_REMOVABLE Tcl_Obj*
-TSP_Util_const_double(double d) {
-    Tcl_Obj* constObj;
-    constObj = Tcl_NewDoubleObj(d);
-    Tcl_IncrRefCount(constObj);
-    return constObj;
-}
-
-
-
diff --git a/native/clang/cvs/backup_n.2021-07-30_16-32.tcl b/native/clang/cvs/backup_n.2021-07-30_16-32.tcl
deleted file mode 100755
index 82fed8a..0000000
--- a/native/clang/cvs/backup_n.2021-07-30_16-32.tcl
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/usr/bin/tclsh
-## exec tclkit
-## Backup
-
-set t [clock format [clock seconds] -format "%Y-%m-%d_%H-%M"]
-catch {console show}
-file mkdir "./cvs"
-foreach f0 [glob -nocomplain [file join "./" *]] {
-    if {[file isfile $f0]} {
-        set f [file tail $f0]
-        set n [file rootname $f]
-        set x [file extension $f]
-        set t0 [file mtime $f0]
-        set ts0 [clock format $t0 -format "%Y-%m-%d_%H-%M"]
-        #if {$f!=[file tail $::argv0]} {
-            set f1 "./cvs/$n.$ts0$x"
-            if {![file exists $f1]} { 
-                puts "copy $f0 $f1"
-                file copy $f0 $f1
-            }
-        #}
-    }
-}

From 3883a73e4867d2d7d5b51b469a4fe302139a897a Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Tue, 26 Jul 2022 20:06:45 +0200
Subject: [PATCH 27/39] Code cleaning Started cleaning up the crude
 package-building code (But package-building is still experimental) Move
 tcc4tcl_helper.tcl here, so no more external dependencies Changed
 implementation for external compiler directives

---
 .../tcc4tcl_helper.tcl => tcc4tcl_helper.tcl  | 555 +++++++++++-------
 tcc4tcl_helper/pkgIndex.tcl                   |   1 -
 tsp-clang.tcl                                 |   8 +-
 tsp-compile.tcl                               |   2 +-
 tsp-packagehelper.tcl                         | 173 ++++--
 5 files changed, 461 insertions(+), 278 deletions(-)
 rename tcc4tcl_helper/tcc4tcl_helper.tcl => tcc4tcl_helper.tcl (64%)
 delete mode 100644 tcc4tcl_helper/pkgIndex.tcl

diff --git a/tcc4tcl_helper/tcc4tcl_helper.tcl b/tcc4tcl_helper.tcl
similarity index 64%
rename from tcc4tcl_helper/tcc4tcl_helper.tcl
rename to tcc4tcl_helper.tcl
index 3609fd0..fd6754d 100644
--- a/tcc4tcl_helper/tcc4tcl_helper.tcl
+++ b/tcc4tcl_helper.tcl
@@ -2,6 +2,12 @@ package provide tcc4tcl_helper 0.1
 
 namespace eval tccenv {
     # some common envelope vars for our ide
+    # this tries to analyze the surrounding dirs
+    # to find a suitable external compiler
+    # on windows this would be tcc.exe
+    # or gcc.exe
+    # someday this should be moved into tccide, since it's nothing to do with tcc4tcl
+    
     variable localdir [pwd]
     variable pathprefix [file dirname [file dirname [file dirname [info script]]]]
     #puts "pwd [pwd] exe [info nameofexecutable] script [info script] prefix $pathprefix"
@@ -23,6 +29,11 @@ namespace eval tccenv {
     
     variable includes_missing ""
     
+    variable EXTERNAL_COMPILERS ""
+    variable CC_DIRECTIVES ""
+    
+    # the following routines try to find tcc.exe and gcc.exe under win32 and set the tccenv vars accordingly
+    
     proc setprojectdir {pdir} {
         variable projectdir
         variable projectincludedir
@@ -31,25 +42,31 @@ namespace eval tccenv {
         set projectincludedir  ${projectdir}/include
         set projectlibdir      ${projectdir}/lib
     }
-    proc settccexedir {pdir} {
+    proc settccexedir {pdir {searchpathin ""}} {
         variable tccexecutabledir
         variable tccexecutable
         variable tccmaindir
         variable tccincludedir
         variable tcclibdir
-        set searchpath {"" "tcc_0.9.27-bin"}
+        set searchpath {""}
+        foreach path $searchpathin {
+            lappend searchpath "$path"
+        }
         set tccexecutabledir [findfiledir $pdir $searchpath "tcc.exe"]
         set tccmaindir  [file normalize ${tccexecutabledir}/]
         set tccincludedir  ${tccexecutabledir}/include
         set tcclibdir      ${tccexecutabledir}/lib
     }
-    proc setgccexedir {pdir} {
+    proc setgccexedir {pdir {searchpathin ""}} {
         variable gccexecutabledir
         variable gccexecutable
         variable gccmaindir
         variable gccincludedir
         variable gcclibdir
-        set searchpath {"" "gcc/bin" "tcc_0.9.27-bin/gcc/bin"}
+        set searchpath {"" "gcc/bin"}
+        foreach path $searchpathin {
+            lappend searchpath "$path" "$path/gcc/bin" 
+        }
         set gccexecutabledir [findfiledir $pdir $searchpath "gcc.exe"]
         set gccmaindir  [file normalize ${gccexecutabledir}/../../]
         set gccincludedir  ${gccmaindir}/include
@@ -127,53 +144,6 @@ proc ::tcc4tcl::searchDir {dir inDir} {
         return ""
 }
 
-proc ::tcc4tcl::commonsubdir {d1 d2} {
-    # returns a list of three
-    # common dirpath
-    # rest of dir1
-    # rest of dir2
-    
-    set d1 [split [string map {\\ /} $d1] /]
-    set d2 [split [string map {\\ /} $d2] /]
-    set l1 [llength $d1]
-    set l2 [llength $d2]
-    if {$l1>$l2} {
-        # swap d1 d2
-        set d $d1
-        set d1 $d2
-        set d2 $d
-        set l1 $l2
-    }
-    set outlist {}
-    for {set i 0} {$i< $l1} {incr i} {
-        if {[lindex $d1 $i]==[lindex $d2 $i]} {
-            lappend outlist [lindex $d1 $i]
-        } else {
-            break;
-        }
-    }
-    set rest1 [lrange $d1 $i end]
-    set rest2 [lrange $d2 $i end]
-        
-    return [list [join $outlist /]/ [join $rest1 /] [join $rest2 /]]
-}
-
-proc ::tcc4tcl::makefileglob {includepath {filelist {}} {subdirs 1}} {
-    # create a filelist withh every file in every subpath as a lookup table
-    foreach path $includepath {
-        #puts "Searching $path"
-        set files [glob -tails -nocomplain -directory $path *.{h,c}]
-        foreach file $files {
-            lappend filelist $file $path
-        }
-        if {$subdirs>0} {
-            set subpaths [glob -nocomplain -directory $path -types d *]
-            set filelist [::tcc4tcl::makefileglob $subpaths $filelist $subdirs]
-        }
-    }
-    return $filelist
-}
-
 proc ::tcc4tcl::shortenpath {path {prefix ""}} {
     #
     set shortincludepath ""
@@ -197,17 +167,7 @@ proc ::tcc4tcl::shortenpath {path {prefix ""}} {
 proc ::tcc4tcl::analyse_includes {handle {prefix ""}} {
     variable includes_missing
     set includes_missing ""
-    set code [$handle code]
-    #puts [string range $code 0 1024]
-    set includepath [$handle add_include_path]
-    append includepath " [::tcc4tcl::getsubdirs $includepath]"
-    set includepath [lsort -unique $includepath]
-    #puts $includepath
-    set filelist [::tcc4tcl::makefileglob $includepath]
-    
-    set usedpath [analyse_codeincludes "main source" $code $includepath ""]
-    puts "Possibly missing files: [expr [llength $includes_missing]/2]"
-    puts "list is in tcc4tcl::includes_missing"
+    set usedpath [$handle add_include_path]
     set shortincludepath ""
     if {$prefix==""} {
         set prefix $::tccenv::pathprefix/
@@ -228,79 +188,197 @@ proc ::tcc4tcl::analyse_includes {handle {prefix ""}} {
     return $shortincludepath
 }
 
-proc ::tcc4tcl::analyse_codeincludes {fromfile code includepath mdone {usedpath ""}} {
-    # a simple (too simple) routine to find all include files and their paths recursivly
-    # unable to parse any kind of ifdef ifndef
-    # so will mostly try to find ANY file thats behind an #include directive
-    
-    variable done
-    variable includes_missing
-    #puts "Analysing ... $fromfile"
-    update
-    set done $mdone
-    set cinc 0
-    set includer "#include"
-    set rgincluder "#(\\s*)include"
-    set lines [split $code \n]
-    foreach line $lines {
-        #set pos [string first $includer [string tolower $line]]
-        set pos [regexp -nocase $rgincluder $line]
-        if {$pos>0} {
-            # found includer
-            set line [string range $line $pos end]
-            set rest [string range $line [string length $includer] end]
-            set start [string first "\"" $rest]
-            set end [string first "\"" $rest $start+1]
-            if {$start==-1} {
-                set start [string first "<" $rest]
-                set end [string first ">" $rest $start+1]
-            }
-            set filename [string trim [string range $rest $start+1 $end-1]]
-            if {$filename==""} {
-                continue
+proc ::tcc4tcl::addExternalCompiler {compiler ccOptions exeDir exeFile {compilertype gccwin32}} {
+    # add external compiler to list EXTERNAL_COMPILERS
+    # $compiler:        compilername cc
+    # $ccOptions       additional options to use with cc
+    # $exeDir           directory to execute cc in
+    # $exeFile          cc to execute
+    # compilertype      can be gccwin32/gcclin64/tccwin32/tcclin64/user   and defines prebuilt ccOptions to use; set to user to have no predefined options
+    dict set ::tccenv::EXTERNAL_COMPILERS $compiler [list $compiler $ccOptions $exeDir $exeFile $compilertype]
+}
+
+proc ::tcc4tcl::prepare_compilerdirectives {filepath handle} {
+    proc relTo {targetfile currentpath } {
+        # Get relative path to target file from current path
+        # First argument is a file name, second a directory name (not checked)
+        set result ""
+        set cc [file split [file normalize $currentpath]]
+        set tt [file split [file normalize $targetfile]]
+        set shorthandpath [file join [file normalize [pwd]] $targetfile]
+        if {![file exists $shorthandpath]} {
+            set shorthandpath [file join [file normalize $currentpath] $targetfile]
+            if {[file exists $shorthandpath]} {
+                # seems to be a direct hit
+                return $targetfile
             }
-            if {[lsearch $done $filename]==-1} {
-                while {[string range $filename 0 2] eq "../"} {
-                    set filename [string range $filename 3 end]
-                }
-                #puts "Searching ...$filename..."
-                #update
-                set undone 1
-                foreach path $includepath {
-                    if {[file exists [file join $path $filename]]} {
-                        set undone 0
-                        lappend done $filename
-                        lappend usedpath $path
-                        if {[file tail $filename]!=$filename} {
-                            #lappend done [file tail $filename]
-                            lappend usedpath [file join $path [file dir $filename]]
-                            #puts "Found $filename (adding [file join $path [file dir $filename]] and [file tail $filename])"
-                        }
-                        set fp [open [file join $path $filename]]
-                        set codenew [read $fp]
-                        close $fp
-                        #puts "found [file join $path $filename]"
-                        incr cinc
-                        set usedpath [analyse_codeincludes $filename $codenew $includepath $done $usedpath]
-                    } 
-                }
-                if {$undone>0} {
-                    #puts "Not found include  $fromfile -> $filename";
-                    lappend includes_missing $fromfile $filename
-                    lappend done $filename
-                }
+        }
+            
+        if {![string equal [lindex $cc 0] [lindex $tt 0]]} {
+            # not on *n*x then
+            return -code error "$targetfile not on same volume as $currentpath"
+        }
+        while {[string equal [lindex $cc 0] [lindex $tt 0]] && [llength $cc] > 0} {
+            # discard matching components from the front
+            set cc [lreplace $cc 0 0]
+            set tt [lreplace $tt 0 0]
+        }
+        set prefix {} 
+        if {[llength $cc] == 0} {
+            # just the file name, so targetfile is lower down (or in same place)
+            set prefix .
+        }
+        # step up the tree
+        for {set i 0} {$i < [llength $cc]} {incr i} {
+            append prefix { ..}
+        }
+        # stick it all together
+        set result [file join {*}$prefix {*}$tt]
+        return $result
+        
+    }
+    proc eol {} {
+        switch -- $::tcl_platform(platform) {
+            windows {return \r\n}
+            unix {return \n}
+            macintosh {return \r}
+            default {\n}
+        }
+    }
+    
+    # This proc tries to guess the shell commands to invoke an external compiler
+    # therefor it uses $::tccenv::tccmaindir as a base directory
+    # ideally, tccide gets executed from $::tccenv::tccmaindir
+    # usually, your directory struct should look like this
+    #
+    # ::tccenv::tccmaindir/
+    # tcc.exe                   executable for external compiler (tcc)
+    # include/...               standard include dir for tcc, holding also tcl.h etc in include/generic
+    # win32/...                 standard win32 includes for tcc
+    # lib/...                   here go libtclstub86.a etc, tcc win32 defs libtcc1.a etc
+    # tsp-package/native/clang  the include files for TSP go here
+    #
+    # when using gcc win32, all gcc stuff goes into
+    # ::tccenv::tccmaindir/gcc
+    # the binaries gcc.exe etc now are under 
+    # ::tccenv::tccmaindir/gcc/bin
+    # 
+    # under linux, gcc oder xgcc should be installed and bring there own includes etc.
+    # 
+    # other compilers may need different treatment
+    # so be shure to set tccmaindir accordingly beforehand
+    
+    # add external compiler to list EXTERNAL_COMPILERS
+    # $compiler:        compilername cc
+    # $ccOptions       additional options to use with cc
+    # $exeDir           directory to execute cc in
+    # $exeFile          cc to execute
+    # $compilertype      can be gccwin32/gcclin64/tccwin32/tcclin64/user   and defines prebuilt ccOptions to use; set to user to have no predefined options
+    puts "Making Directives for $filepath ($::tccenv::tccmaindir)" 
+    set pathway [::tcc4tcl::analyse_includes $handle]
+    #puts "Paths: $pathway"
+    set includestccwin32 "-Iinclude -Iinclude/stdinc -Iinclude/generic -Iinclude/generic/win -Iinclude/xlib -Iwin32 -Iwin32/winapi "
+    set includesgccwin32 "-Iinclude -Iinclude/generic -Iinclude/generic/win -Iinclude/xlib"
+    set includestcclin64 "-Iinclude -Iinclude/stdinc -Iinclude/generic -Iinclude/generic/unix -Iinclude/xlib "
+    set includesgcclin64 "-Iinclude -Iinclude/generic -Iinclude/generic/unix -Iinclude/xlib"
+    set includesuser ""
+
+    set librariestccwin32 "-ltclstub86elf -ltkstub86elf"
+    set librariestcclin64 "-ltclstub86elf -ltkstub86elf"
+    set librariesgccwin32 "-Llib -ltclstub86 -ltkstub86"
+    set librariesgcclin64 "-Llib -ltclstub86_64 -ltkstub86_64"
+    set librariesuser ""
+    
+    set ccoptionstccwin32 "-m32 -D_WIN32 "
+    set ccoptionsgccwin32 "-s -m32 -D_WIN32 -static-libgcc "
+    set ccoptionstcclin64 ""
+    set ccoptionsgcclin64 "-s -fPIC -D_GNU_SOURCE "
+    
+    set ccoptionstccuser ""
+    
+    set includes_generic ""
+    
+    foreach incpath $pathway {
+        #puts "include $incpath relTo $::tccenv::tccmaindir --> [relTo $incpath $::tccenv::tccmaindir]"
+        if {[string first include/ [string tolower $incpath]]<0} {
+            if {[string first win32 [string tolower $incpath]]<0} {
+                lappend includes_generic "-I[relTo $incpath $::tccenv::tccmaindir]"
             }
         }
     }
-    return [lsort -unique $usedpath]
+    
+    set libraries_addon ""
+    lappend libraries_addon "-Llib"
+    set libps [$handle add_library_path]
+    set libs [$handle add_library]
+    foreach inclib $libs {
+        lappend libraries_addon "-l$inclib"
+    }
+    foreach incpath $libps {
+        lappend libraries_addon "-L[relTo $incpath $::tccenv::tccmaindir]"
+    }
+
+    set packagename [file rootname [file tail $filepath]]
+    set filepath [file dirname $filepath]
+    
+    if {[string first $::tccenv::tccmaindir $::tccenv::localdir]<0} {
+        set absfilepath [file normalize $filepath]
+    } else {
+        set absfilepath $filepath
+    }
+    
+    set relfilepath [relTo $filepath $::tccenv::tccmaindir]
+    set ccdirectives ""
+    foreach {compiler ccdetails} $::tccenv::EXTERNAL_COMPILERS {
+        # ok, spit out all directives and put it into dict CC_DIRECTIVES
+        set cc ""
+        lassign $ccdetails cc ccOptions exeDir exeFile compilertype
+        if {$cc eq ""} {
+            puts "ERROR: Unknown compiler $compiler or given none..."
+            continue;
+        }
+        
+        set includes [set [subst includes[set compilertype]]]
+        set libraries [set [subst libraries[set compilertype]]]
+        set ccoptions [set [subst ccoptions[set compilertype]]]
+        append libraries " $libraries_addon"
+        append inlcudes " $includes_generic"
+        
+        set dlext "dll"
+        if {[string first "lin64" $compilertype]>-1} {
+            set dlext "so"
+        }
+        
+        set cfile [file join $relfilepath "$packagename.c"]
+        set ofile [file join $relfilepath "$packagename.$dlext"]
+        
+        set ccpath [file join $exeDir $exeFile]
+        append ccoptions " -shared -DUSE_TCL_STUBS -O2"
+        append ccOptions " $ccoptions"
+        
+        puts "Directive for $compiler"
+        puts "$ccpath $ccOptions $includes $includes_generic $cfile -o$ofile $libraries"
+        lappend ccdirectives $compiler "$ccpath $ccOptions $includes $includes_generic $cfile -o$ofile $libraries"
+    }
+    return $ccdirectives
 }
 
 proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packageversion 1.0} {tclversion TCL_VERSION}} {
-    proc relTo {targetfile currentpath} {
-    # Get relative path to target file from current path
-    # First argument is a file name, second a directory name (not checked)
+    proc relTo {targetfile currentpath } {
+        # Get relative path to target file from current path
+        # First argument is a file name, second a directory name (not checked)
+        set result ""
         set cc [file split [file normalize $currentpath]]
         set tt [file split [file normalize $targetfile]]
+        set shorthandpath [file join [file normalize [pwd]] $targetfile]
+        if {![file exists $shorthandpath]} {
+            set shorthandpath [file join [file normalize $currentpath] $targetfile]
+            if {[file exists $shorthandpath]} {
+                # seems to be a direct hit
+                return $targetfile
+            }
+        }
+            
         if {![string equal [lindex $cc 0] [lindex $tt 0]]} {
             # not on *n*x then
             return -code error "$targetfile not on same volume as $currentpath"
@@ -320,7 +398,9 @@ proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packagevers
             append prefix { ..}
         }
         # stick it all together
-        file join {*}$prefix {*}$tt
+        set result [file join {*}$prefix {*}$tt]
+        return $result
+        
     }
     proc eol {} {
         switch -- $::tcl_platform(platform) {
@@ -367,106 +447,25 @@ proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packagevers
     # beautify code
     set mycode [::tcc4tcl::reformat [string map [list [eol] \n] $mycode] 4]
     set $state(type) $oldtype
-    puts [$handle add_include_path] 
-    
-    set pathway [::tcc4tcl::analyse_includes $handle]
-    #puts "Paths: $pathway"
-    set includestcc "-Iinclude -Iinclude/stdinc -Iinclude/generic -Iinclude/generic/win -Iinclude/xlib -Iwin32 -Iwin32/winapi "
-    set includesgcc "-Iinclude -Iinclude/generic -Iinclude/generic/win -Iinclude/xlib"
-    set includeslin64 "-Iinclude -Iinclude/generic -Iinclude/generic/unix -Iinclude/xlib"
-    set librariestcc "-ltclstub86elf -ltkstub86elf"
-    set librariesgcc "-Llib -ltclstub86 -ltkstub86"
-    set librarieslin64 "-Llib -ltclstub86_64 -ltkstub86_64"
-    
-    foreach incpath $pathway {
-        #lappend includestcc "-I$incpath"
-        if {[string first include/ [string tolower $incpath]]<0} {
-            if {[string first win32 [string tolower $incpath]]<0} {
-                lappend includestcc "-I$incpath"
-                lappend includesgcc "-I$incpath"
-                lappend includeslin64 "-I$incpath"
-            }
-        }
-    }
-    lappend librariestcc "-Llib"
-    lappend librariesgcc "-Llib"
-    lappend librarieslin64 "-Llib"
-    set libps [$handle add_library_path]
-    set libs [$handle add_library]
-    foreach inclib $libs {
-        lappend librariestcc "-l$inclib"
-        set found 0
-        foreach incpath $libps {
-            if {[file exists [file join $incpath ${inclib}.dll]]} {
-                lappend librariesgcc [file join $incpath $inclib.dll]
-                set found 1
-                break
-            }
-            if {[file exists [file join $incpath ${inclib}.so]]} {
-                lappend librarieslin64 [file join $incpath $inclib.so]
-                set found 1
-                break
-            }
-        }
-        foreach incpath $libps {
-            if {[file exists [file join $incpath lib${inclib}.a]]} {
-                lappend librariesgcc [file join $incpath $inclib.dll]
-                set found 1
-                break
-            }
-            if {[file exists [file join $incpath lib${inclib}.so]]} {
-                lappend librarieslin64 [file join $incpath $inclib.so]
-                set found 1
-                break
-            }
-        }
-        if {$found ==0} {
-            puts "Warning: Not found library $inclib"
-            lappend librariesgcc $inclib
-        }
-            
-    }
-    foreach incpath $libps {
-        lappend librariestcc "-L$incpath"
-        lappend librariesgcc "-L$incpath"
-    }
-    
-    if {[string first $::tccenv::tccexecutabledir $::tccenv::localdir]<0} {
-        set absfilepath [file normalize $filepath]
-    } else {
-        set absfilepath $filepath
-    }
-    
-    set relfilepath [relTo $filepath $::tccenv::tccmaindir]
-    
-    set tccpath [file join $::tccenv::tccexecutabledir $::tccenv::tccexecutable]
-    set gccpath [file join $::tccenv::gccexecutabledir $::tccenv::gccexecutable]
-    set gccoptions "-O2 -fwhole-program"
-    set gccoptions "-O2 -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,-s"
-    set gccoptions "-O2"
-    set tcc_compile "$tccpath -shared -DUSE_TCL_STUBS $includestcc [file join $absfilepath "$packagename.c"] -o[file join $absfilepath "$packagename.dll"] $librariestcc"
-    set gcc_compile "$gccpath -shared -s -m32 -D_WIN32 -DUSE_TCL_STUBS -static-libgcc $includesgcc [file join $absfilepath "$packagename.c"] $librariesgcc  -o[file join $absfilepath "$packagename.dll"] $gccoptions"
-    set cross_compile "i686-w64-mingw32-gcc -shared -s -m32 -D_WIN32 -DUSE_TCL_STUBS -static-libgcc $includesgcc [file join $relfilepath "$packagename.c"] $librariesgcc  -o[file join $relfilepath "$packagename.dll"] $gccoptions"
-    set lin64_compile "gcc -shared -s -fPIC -D_GNU_SOURCE -DUSE_TCL_STUBS $includeslin64 [file join $relfilepath "$packagename.c"] $librarieslin64  -o[file join $relfilepath "$packagename.so"] $gccoptions"
-
-    puts "\n$tcc_compile\n"
-    puts "\n$gcc_compile\n"
-    puts "\n$cross_compile\n"
-    puts "\n$lin64_compile\n"
+    #puts [$handle add_include_path] 
     
     set filename [file join $filepath "$packagename.c"]
-
+    set ccdirectives [::tcc4tcl::prepare_compilerdirectives $filename $::tsp::TCC_HANDLE]
     set fp [open $filename w]
     puts $fp "/***************** Automatically Created with TCC4TCL Helper and maybe TSP **********************************/"
     puts $fp "/* Compiler directives are raw estimates, please adapt to given pathstructure */\n"
-    puts $fp "/* $tcc_compile  */\n"
-    puts $fp "/* $gcc_compile */\n"
-    puts $fp "/* $cross_compile  */\n"
-    puts $fp "/* $lin64_compile  */\n"
+    #puts $fp "/* $tcc_compile  */\n"
+    #puts $fp "/* $gcc_compile */\n"
+    #puts $fp "/* $cross_compile  */\n"
+    #puts $fp "/* $lin64_compile  */\n"
+    foreach {compiler ccdirective} $ccdirectives {
+        puts $fp "/* for $compiler use */"
+        puts $fp "/* $ccdirective */\n"
+    }
     puts $fp "/***************** Automatically Created with TCC4TCL Helper and maybe TSP **********************************/"
     puts $fp $mycode
     close $fp
-    return [list $tcc_compile $gcc_compile $cross_compile $lin64_compile]
+    return $ccdirectives
 }
 
 proc ::tcc4tcl::reformat {tclcode {pad 4}} {
@@ -550,3 +549,121 @@ proc ::tcc4tcl::reformat {tclcode {pad 4}} {
     return $out
 }
 
+#----------------------------------- remove this code in future versions -----------------------
+proc ::tcc4tcl::____analyse_codeincludes {fromfile code includepath mdone {usedpath ""}} {
+    # a simple (too simple) routine to find all include files and their paths recursivly
+    # unable to parse any kind of ifdef ifndef
+    # so will mostly try to find ANY file thats behind an #include directive
+    
+    variable done
+    variable includes_missing
+    #puts "Analysing ... $fromfile"
+    update
+    set done $mdone
+    set cinc 0
+    set includer "#include"
+    set rgincluder "#(\\s*)include"
+    set lines [split $code \n]
+    foreach line $lines {
+        #set pos [string first $includer [string tolower $line]]
+        set pos [regexp -nocase $rgincluder $line]
+        if {$pos>0} {
+            # found includer
+            set line [string range $line $pos end]
+            set rest [string range $line [string length $includer] end]
+            set start [string first "\"" $rest]
+            set end [string first "\"" $rest $start+1]
+            if {$start==-1} {
+                set start [string first "<" $rest]
+                set end [string first ">" $rest $start+1]
+            }
+            set filename [string trim [string range $rest $start+1 $end-1]]
+            if {$filename==""} {
+                continue
+            }
+            if {[lsearch $done $filename]==-1} {
+                while {[string range $filename 0 2] eq "../"} {
+                    set filename [string range $filename 3 end]
+                }
+                #puts "Searching ...$filename..."
+                #update
+                set undone 1
+                foreach path $includepath {
+                    if {[file exists [file join $path $filename]]} {
+                        set undone 0
+                        lappend done $filename
+                        lappend usedpath $path
+                        if {[file tail $filename]!=$filename} {
+                            #lappend done [file tail $filename]
+                            lappend usedpath [file join $path [file dir $filename]]
+                            #puts "Found $filename (adding [file join $path [file dir $filename]] and [file tail $filename])"
+                        }
+                        set fp [open [file join $path $filename]]
+                        set codenew [read $fp]
+                        close $fp
+                        #puts "found [file join $path $filename]"
+                        incr cinc
+                        set usedpath [analyse_codeincludes $filename $codenew $includepath $done $usedpath]
+                    } 
+                }
+                if {$undone>0} {
+                    #puts "Not found include  $fromfile -> $filename";
+                    lappend includes_missing $fromfile $filename
+                    lappend done $filename
+                }
+            }
+        }
+    }
+    return [lsort -unique $usedpath]
+}
+
+proc ::tcc4tcl::____makefileglob {includepath {filelist {}} {subdirs 1}} {
+    # create a filelist withh every file in every subpath as a lookup table
+    foreach path $includepath {
+        #puts "Searching $path"
+        set files [glob -tails -nocomplain -directory $path *.{h,c}]
+        foreach file $files {
+            lappend filelist $file $path
+        }
+        if {$subdirs>0} {
+            set subpaths [glob -nocomplain -directory $path -types d *]
+            set filelist [::tcc4tcl::makefileglob $subpaths $filelist $subdirs]
+        }
+    }
+    return $filelist
+}
+
+proc ::tcc4tcl::____commonsubdir {d1 d2} {
+    # returns a list of three
+    # common dirpath
+    # rest of dir1
+    # rest of dir2
+    
+    set d1 [split [string map {\\ /} $d1] /]
+    set d2 [split [string map {\\ /} $d2] /]
+    set l1 [llength $d1]
+    set l2 [llength $d2]
+    if {$l1>$l2} {
+        # swap d1 d2
+        set d $d1
+        set d1 $d2
+        set d2 $d
+        set l1 $l2
+    }
+    set outlist {}
+    for {set i 0} {$i< $l1} {incr i} {
+        if {[lindex $d1 $i]==[lindex $d2 $i]} {
+            lappend outlist [lindex $d1 $i]
+        } else {
+            break;
+        }
+    }
+    set rest1 [lrange $d1 $i end]
+    set rest2 [lrange $d2 $i end]
+        
+    return [list [join $outlist /]/ [join $rest1 /] [join $rest2 /]]
+}
+
+
+
+
diff --git a/tcc4tcl_helper/pkgIndex.tcl b/tcc4tcl_helper/pkgIndex.tcl
deleted file mode 100644
index ea01d00..0000000
--- a/tcc4tcl_helper/pkgIndex.tcl
+++ /dev/null
@@ -1 +0,0 @@
-package ifneeded tcc4tcl_helper 0.1 [list source [file join $dir tcc4tcl_helper.tcl]]
diff --git a/tsp-clang.tcl b/tsp-clang.tcl
index 604cf12..18f4d1b 100644
--- a/tsp-clang.tcl
+++ b/tsp-clang.tcl
@@ -1142,9 +1142,9 @@ if {[dict get $compUnit isNative]==0} {
     Tcl_PushCallFrame(interp, frame, Tcl_GetGlobalNamespace(interp), 1);
     }
     set popcf "    Tcl_PopCallFrame(interp); \\\n    ckfree((char*) frame) \n"
-    puts "$name is NOT a native proc"
+    #puts "$name is NOT a native proc"
 } else {
-    puts "$name is a native proc"
+    #puts "$name is a native proc"
 }
 
 
@@ -1471,9 +1471,9 @@ proc ::tsp::lang_compile {compUnitDict code} {
             ::tsp::addWarning compUnit "TCC: $compResult"
             dict set compUnit compiledReference tsp.cmd.${name}Cmd
         } else {
-            puts "Writing Package deffered"
+            #puts "Writing Package deffered"
         }
-        puts "Transpiling done"
+        #puts "Transpiling done"
     } result ]
     if {$result ne ""} {
         puts "Transpile Result: $result"
diff --git a/tsp-compile.tcl b/tsp-compile.tcl
index 9d7d7ba..efa2d2b 100644
--- a/tsp-compile.tcl
+++ b/tsp-compile.tcl
@@ -162,7 +162,7 @@ proc ::tsp::compile_proc {file name procargs body} {
             ::tsp::logErrorsWarnings compUnit
         } else {
             # parse_body ok, let's see if we can compile it
-            puts "Generating C-Code\n"
+            #puts "Generating C-Code\n"
             set compilable [::tsp::lang_create_compilable compUnit $code]
             ::tsp::logCompilable compUnit [join $compilable ""]
             set rc [::tsp::lang_compile compUnit $compilable]
diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index a2299bd..781f730 100644
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -13,6 +13,9 @@
 # 
 ##############################################################################
 
+source [file join [file dirname [info script]] tcc4tcl_helper.tcl]
+
+
 namespace eval ::tsp {
     # added for code package making MiR
     variable COMPILE_PACKAGE 0
@@ -39,6 +42,30 @@ namespace eval ::tsp {
     variable ACTSOURCE "__lastsaved__.tcl"
 }
 
+proc ::tsp::hook_proc {} {
+    # we hook the proc construct to get information about package defined procs
+    if {[info command ::__proc] eq ""} {
+        rename ::proc ::__proc
+        ::__proc ::proc {procName procargs procbody} {
+            lappend ::tsp::TCL_PROCS  [list $procName $procargs $procbody]
+            if {[catch {uplevel 0 ::__proc [list $procName $procargs $procbody]} err]} {
+                rename ::proc ""
+                rename ::__proc ::proc
+                return -code error "Error in proc $err"
+            }
+        }
+    }
+}
+
+proc ::tsp::unhook_proc {} {
+    # release the hooked proc construct
+    # if you eval external code, don't forget to handle errors in eval and call unhook_proc, just in case
+    if {[info command ::__proc] eq "::__proc"} {
+        rename ::proc ""
+        rename ::__proc ::proc
+    }
+}
+
 proc ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0} {tclversion TCL_VERSION}} {
     if {$packagename eq ""} {
         puts "Err: No package name given: use init_package packagename {packagenamespace ""} {packageversion 1.0} {tclversion TCL_VERSION}"
@@ -97,24 +124,12 @@ unsigned short __tcc_int_fpu_control = 0x137f | 0x0c00;
     set ::tsp::LOAD_DLLS "" 
     set ::tsp::EXTERNAL_DLLS "" 
     
-    if {[info command ::__proc] eq ""} {
-        rename ::proc ::__proc
-        ::__proc ::proc {procName procargs procbody} {
-            lappend ::tsp::TCL_PROCS  [list $procName $procargs $procbody]
-            if {[catch {uplevel 0 ::__proc [list $procName $procargs $procbody]} err]} {
-                rename ::proc ""
-                rename ::__proc ::proc
-                return -code error $err
-            }
-        }
-    }
+    ::tsp::hook_proc
 }
 
 proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
-    if {[info command ::__proc] eq "::__proc"} {
-        rename ::proc ""
-        rename ::__proc ::proc
-    }
+    ::tsp::unhook_proc
+
     if {$::tsp::PACKAGE_NAME eq ""} {
          puts "Err: No package name given: use init_package packagename"
         set ::tsp::COMPILE_PACKAGE 0
@@ -169,6 +184,27 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
     set ::tsp::PACKAGE_NAME ""
 }
 
+proc ::tsp::addExternalCompiler {compiler ccOptions exeDir exeFile {compilertype gccwin32}} {
+    # add external compiler to list EXTERNAL_COMPILERS
+    # $compiler:        compilername cc
+    # $ccOptions       additional options to use with cc
+    # $exeDir           directory to execute cc in
+    # $exeFile          cc to execute
+    # compilertype      can be gccwin32/gcclin64/tccwin32/tcclin64/user   and defines prebuilt ccOptions to use; set to user to have no predefined options
+    tcc4tcl::addExternalCompiler $compiler $ccOptions $exeDir $exeFile $compilertype 
+}
+
+proc ::tsp::safeEval {cmd} {
+    # eval string cmd in global namespace, catch errors and eventually reset proc handler
+    if {[catch {
+        set r [namespace eval :: "$cmd"]
+        puts "Result: $r"
+    } err]} {
+        ::tsp::unhook_proc
+        puts "Eval Error: $err"
+    }
+}
+
 proc ::tsp::add_tclinclude {fname} {
     # load tcls for additional sources
     lappend ::tsp::LOAD_TCLS $fname
@@ -184,6 +220,7 @@ proc ::tsp::add_dllinclude {fname} {
 
 proc ::tsp::test_packageX {packagename {callcmd ""} {shell "./tclkit_866_3.upx.exe"}} {
     # ok, now things really get difficult, if the directory structure doesn't work
+    # this actually only works under windows, you need a tclkit named $shell in the current working dir
     set result "failed testloading package $packagename"
     set callresult ""
     puts "Testing package $packagename"
@@ -249,6 +286,7 @@ proc ::tsp::test_packageX {packagename {callcmd ""} {shell "./tclkit_866_3.upx.e
 
 proc ::tsp::test_package {packagename {callcmd ""}} {
     # ok, now things really get difficult, if the directory structure doesn't work
+    # careful, loading a dll into the interp leads to a lock on the dll file, so recompiling it will fail due to writelock
     set result "failed testloading package $packagename"
     set callresult ""
     puts "Testing package $packagename"
@@ -331,7 +369,7 @@ proc ::tsp::rewrite_procnamespace {} {
         if {[lsearch $::tsp::PACKAGE_PROCS [namespace tail $procname]]<0} {
             # pure c implemented... probs ahead :-)
             set procdef [list $procname "args" [list puts "Not implemented \"$procname\""]]
-            puts "found pure c proc $procname, replacing dummy $procdef"
+            #puts "found pure c proc $procname, replacing dummy $procdef"
             lappend ::tsp::PACKAGE_PROCS $procname $procdef
             set cdef [dict get $state(procdefs) $procname]
             lassign $cdef cprocname rtype cprocargs
@@ -374,7 +412,7 @@ proc ::tsp::write_pkgIndex {packagename} {
         lassign $procdef cproc cvars cbody
         puts $fd "# ${::tsp::PACKAGE_NAMESPACE}::$cproc $cvars"
     }
-    puts $fd "# TCL Procs "
+    puts $fd "\n# TCL Procs "
     puts $fd ""
     set tclpr {}
     catch {set tclpr $::tsp::TCL_PROCS}
@@ -481,7 +519,7 @@ proc ::tsp::write_pkgAltTcl {packagename} {
     }
     close $fd
     
-    ::tsp::splice_src  "$::tsp::ACTSOURCE"
+    #::tsp::splice_src  "$::tsp::ACTSOURCE"
     set filename [file join $tsp::PACKAGE_DIR "${packagename}.puretcl.tcl"]
     set fd [open $filename w]
     puts $fd "#  TSP Pure TCL procs for loadlib complemenary procs"
@@ -504,20 +542,47 @@ proc ::tsp::write_pkgAltTcl {packagename} {
         if {$procname eq "${packagename}_pkgInit"} {
             set ::tsp::PACKAGE_INIT_PROC 1
         }
-        puts $fd "proc ${procname} {$procargs} {$procbody}"
+        puts $fd "proc ${procname} {$procargs} {$procbody}\n"
     }
     
     close $fd
 }
 
-proc ::tsp::compile_package {packagename {compiler tcc}} {
+proc ::tsp::compile_package {packagename {compiler tccwin32}} {
     # evtl compile c-source
+    # compile directives come from tcc4tcl_helper
+    # since tccide is mainly developed for windows
+    # it tries to find tcc.exe and gcc.exe in adjacent dirs to pwd
+    # so, trying to compile the code on external compiler relies on this mechanism
+    # so tcc and gcc options use win32 tcc.exe gcc.exe acoordingly
+    # lin64 tries to call gcc on a linux bash
+    # cross tries calling i686-w64-mingw32-gcc
+    # if this fails, you can still use the generated compiler directives
+    # as a boilerplate for manually compiling the source
+    # compile to memory (intern or memory) and
+    # compile to dynlib (export) 
+    # with the integrated tcc4tcl should however work
+
+    set EXTERNAL_COMPILERS $::tccenv::EXTERNAL_COMPILERS
     
     set ctype -1
-    set ctype [dict get "none -1 tcc 0 gcc 1 cross 2 lin64 3 intern 9 memory 9 export 9 debug 99" $compiler]
+    catch {
+        set ctype [dict get "none -1 intern 9 memory 9 export 9 debug 99" $compiler]
+    }
     if {$ctype<0} {
-        puts "ERROR: Unknown compiler $compiler or given none..."
-        return -1
+        # call plugin compiler here
+        set cc ""
+        if {[dict exists $EXTERNAL_COMPILERS $compiler]} {
+            set ccl [dict get $EXTERNAL_COMPILERS $compiler]
+            lassign $ccl cc ccOptions exeDir exeFile compilertype
+        }
+        if {$cc ne ""} {
+            # call compiler 
+        } else {
+            # error not found
+            puts "ERROR: Unknown compiler $compiler or given none..."
+            return -1
+        }
     }
     if {$ctype==9} {
         puts "Compiling in Memory"
@@ -554,12 +619,11 @@ proc ::tsp::compile_package {packagename {compiler tcc}} {
     if {$::tccenv::tccexecutabledir ne ""} {
         cd $::tccenv::tccexecutabledir
     }
-    set cdirect [lindex $tsp::COMPILE_DIRECTIVES $ctype]
-    #set cdirect [string map [list "$packagename.c" $filename] $cdirect]
-    #set cdirect [string map [list "$packagename.dll" $dllname] $cdirect]
+    
+    set cdirect [dict get $tsp::COMPILE_DIRECTIVES $compiler]
     
     puts "Compiling external $cdirect"
-    set ::errorCode ""
+    set  ::errorCode ""
     catch {
         eval exec $cdirect
     } err
@@ -573,32 +637,6 @@ proc ::tsp::compile_package {packagename {compiler tcc}} {
     return 1
 }
 
-proc ::tsp::splice_src {filename} {
-    if {![file exists $filename]} {
-        #puts "ERROR: $filename source not found"
-        return -1
-    }
-
-    set f [open "$filename"]
-    set data [read $f]
-    close $f
-    set ::tsp::TCL_PROCS ""
-    foreach {dummy procName} [regexp -all -inline -line {^[\s:]*proc (\S+)} $data] {
-        catch {
-            set procargs ""
-            set _procargs [info args $procName]
-            foreach _procarg $_procargs {
-                if {[info default $procName $_procarg def]>0} {
-                    set _procarg "$_procarg \"$def\""
-                } 
-                lappend procargs $_procarg
-            }
-            set procbody [info body $procName]
-            lappend ::tsp::TCL_PROCS  [list $procName $procargs $procbody]
-        }
-    }
-}
-
 proc version:filediff {file1 file2 {cmdEqual {version:cmdEqual}} {cmdAdd {version:cmdAdd}} {cmdDel {version:cmdDel}}} {
         set sourcefid1 [open $file1 r]
         set sourcefid2 [open $file2 r]
@@ -712,4 +750,33 @@ proc version:cmdDel {txt line} {
     }
 }
 
+#----------------------------------- Code to remove -----------------------------------------
+
+proc ::tsp::____splice_src {filename} {
+    if {![file exists $filename]} {
+        puts "ERROR: $filename source not found"
+        return -1
+    }
+
+    set f [open "$filename"]
+    set data [read $f]
+    close $f
+    set ::tsp::TCL_PROCS ""
+    foreach {dummy procName} [regexp -all -inline -line {^[\s:]*proc (\S+)} $data] {
+        catch {
+            set procargs ""
+            set _procargs [info args $procName]
+            foreach _procarg $_procargs {
+                if {[info default $procName $_procarg def]>0} {
+                    set _procarg "$_procarg \"$def\""
+                } 
+                lappend procargs $_procarg
+            }
+            set procbody [info body $procName]
+            lappend ::tsp::TCL_PROCS  [list $procName $procargs $procbody]
+        }
+    }
+}
+
+
 

From 5d0f320e948abb7cac69c717c3fe658354154c60 Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Tue, 26 Jul 2022 20:15:59 +0200
Subject: [PATCH 28/39] Re-Updated docs

---
 docs/compiler-usage.md    | 36 ++++++++++++++++-
 docs/tsp-lang-features.md | 83 +++++++++++++++++++++++++++++++++++++--
 2 files changed, 114 insertions(+), 5 deletions(-)

diff --git a/docs/compiler-usage.md b/docs/compiler-usage.md
index ea40115..c4f17ac 100755
--- a/docs/compiler-usage.md
+++ b/docs/compiler-usage.md
@@ -42,12 +42,14 @@ proc can also be specified with a single underscore **('_')**.
 a convenience for `tsp::log _`
 
 
-### `tsp::printLog` *?outfd? ?proc?*
+### `tsp::printLog` *?outfd? ?proc? ?breakeval?*
 
 `tsp::printLog` prints the compiler log.  Optional outfd specifies a writable file handle, stderr
 is the default.  Optional proc is specified, only that log is returned.  The most recent compiled
 proc can also be specified with a single underscore **('_')**.
 
+**breakeval** defaults to 1, so that TSP returns with an error, if there are any errors in transpilation.
+
 
 ## Annotations
 
@@ -100,7 +102,37 @@ vwait, etc.)
             include tracing on variables and the return values.  This can be useful to 
             isolate variable that may cause conversion errors.  See the Tracing section below.
 
-
+### `#tsp::inlinec`
+`#tsp::inlinec` defines a pure c line, that will be put into the source code directly without changes, so it is possible to e.g. call other c-procs directly (given you know the calling conventions) etc.
+
+### `#tsp::altTCL`
+`#tsp::altTCL` is put into the generated tcl code (use if compilation/loading fails), so you can give alternate TCL versions of inlineC parts
+    
+```
+
+#example
+package require tsp
+
+set handle $::tsp::TCC_HANDLE
+$handle cproc t1 {int i} double {;#define a simple c procedure here -- it will be compile as c_t1 later
+    return i*0.5;
+}
+tsp::proc test {} {
+    #tsp::procdef double
+    #tsp::int i
+    #tsp::double l k
+    set k 1.0
+    for {set i 0} {$i<100000} {incr i} {;# $i will be decorated as __i in TSP, $l as __l and so on
+        #tsp::inlinec __l = c_t1(__i);
+        #tsp::altTCL set l [t1 $i]
+        #tsp::inlinec __k = __k+sqrt(__l*__l*0.33);
+        #tsp::altTCL set k [expr {$k+sqrt($l*$l*0.33)}]
+    }
+    return $k
+}
+
+
+```
 
 ## Trace compile type
 
diff --git a/docs/tsp-lang-features.md b/docs/tsp-lang-features.md
index 2a46429..7f4603c 100755
--- a/docs/tsp-lang-features.md
+++ b/docs/tsp-lang-features.md
@@ -50,16 +50,93 @@ a level of additional runtime interpretation.
     lappend foo {*}$s                ;# invalid: expansion syntax not allows
 ```
 
-## Namespace not supported for proc names
+## limited Namespace support for proc names and variables
 
-Currently, procedures can only be defined in the global namespace.
+Procedures can be defined in the global namespace. Namespace qualifiers in the proc name are invalid 
 
 ```
-    tsp::proc ::pkg::foo {} {        ;# invalid: namespace procname not allowed
+    tsp::proc ::pkg::foo {} {        ;# invalid: 
         #tsp::procdef void
     }
 ```
 
+But you can define a project namespace with the variable tsp::PACKAGE_NAMESPACE; if defined, ALL procs will be rewritten to this namespace
+
+```
+set tsp::PACKAGE_NAMESPACE pkg
+    tsp::proc foo {} {        ;# will be rewritten pkg::foo
+        #tsp::procdef void
+        #tsp::var v
+        variable v            ;# will be connected to $pkg::v
+    }
+    
+```
+## Package support
+Package support depends on the package tcc4tcl_helper to work, someday it will be integrated here, meanwhile find it here https://github.com/MichaelMiR01/tccide/tree/main/subpackages
+
+Package support (tsp_packagehelper.tcl) introduces two commands
+* ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0} {tclversion TCL_VERSION}}
+* ::tsp::finalize_package {{packagedir ""} {compiler none}}
+
+TSP will generate package code in the given packagedir (packagedir defaults to packagename).
+It writes out
+
+* packagename.c
+* packagename.tclprocs.tcl
+* packagename.puretcl.tcl
+* pkgIndex.tcl
+* packagename.dll
+
+compiler can be **intern/memory** or **export**. 
+
+   **intern** (eq memory) will compile to memory and immediatly install the compiled procs
+    
+   **export** will build a shared lib (.so//.dll) an write it into the package dir as **packagename.dll // packagename.so**
+
+* packagename.tclprocs.tcl    contains all TSP procs defined as tcl-only and will be sourced, if loading the dll fails
+* packagename.puretcl.tcl     TSP collects all proc definitions between init_package and finalize_package and spits them here. This will be sourced from pkgIndex, so not only tsp and tcc proc are loaded, but tcl procs can also be defined as helpers
+
+```
+#example
+package require tsp
+
+::tsp::init_package tnop 
+
+set handle $tsp::TCC_HANDLE
+$handle cproc cnop {Tcl_Interp* interp } char* {
+    // this is a pure c-function
+     return "cnop";
+}
+::tsp::proc tspnop {} {
+    #this is a transpiled function, its tcl code will go to tnop.tclprocs.tcl
+    #tsp::procdef void
+    puts "tspnop"
+}
+proc tclnop {} {
+    # this is a pure tcl function. its code will go to tnop.puretcl.tcl
+    puts "tclnop "
+}
+::tsp::printLog 
+::tsp::finalize_package tnop export
+```
+
+The exported package can now be loaded with package require packagename.
+
+Furthermore, TSP will try to spit out some compiler directives for tcc/gcc you can use as boilerplate to recompile the sourcecode with an optimizing compiler.
+
+Packages can be enriched with external libraries with the following directives:
+```
+proc ::tsp::add_tclinclude {fname}
+    # load tcls for additional sources, issues a source (fname) command into pkgIndex
+
+proc ::tsp::add_bininclude {fname} 
+    # load_dlls for dlls wich should be loaded into interp, issues a load (fname) command into pkgIndex
+
+proc ::tsp::add_dllinclude {fname}
+    # external dlls wich are dependencies and do not get loaded into interp but linked to your c-code (like jpeg.dll)
+    # tries to copy fname.dll into [pwd], so tcl can find it and dload
+```
+
 ## Limitation on proc name and variable names
 
 Procedure names and variable names inside of procedures must follow strict naming conventions.

From 69e06311e96f661fb2506a38c6bf502fb54f80c9 Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Wed, 27 Jul 2022 19:27:48 +0200
Subject: [PATCH 29/39] More code cleaning Removed all outcommented #puts
 Removed all Critcl stuff Removed unecessary comments

---
 tcc4tcl_helper.tcl    | 135 ------------------------------------------
 tests/test_tsp.tcl    | 101 +++++++++++++++++++++++++++++++
 tsp-clang.tcl         | 122 +++++++-------------------------------
 tsp-compile.tcl       |   1 -
 tsp-packagehelper.tcl |  60 ++-----------------
 5 files changed, 128 insertions(+), 291 deletions(-)
 create mode 100644 tests/test_tsp.tcl

diff --git a/tcc4tcl_helper.tcl b/tcc4tcl_helper.tcl
index fd6754d..0bdc72b 100644
--- a/tcc4tcl_helper.tcl
+++ b/tcc4tcl_helper.tcl
@@ -10,7 +10,6 @@ namespace eval tccenv {
     
     variable localdir [pwd]
     variable pathprefix [file dirname [file dirname [file dirname [info script]]]]
-    #puts "pwd [pwd] exe [info nameofexecutable] script [info script] prefix $pathprefix"
     variable tccexecutabledir $localdir
     variable tccexecutable  tcc.exe
     variable tccmaindir     ${tccexecutabledir}
@@ -92,9 +91,7 @@ namespace eval tccenv {
 
 proc ::tcc4tcl::getsubdirs {includepath} {
     set retpath {}
-    #puts "Entering..."
     foreach path $includepath {
-        #puts "Searching $path..."
         if {![file isdir $path]} {
             #try guessing in current subdirs
             if {[file isdir [::tcc4tcl::shortenpath $path]]} {
@@ -102,7 +99,6 @@ proc ::tcc4tcl::getsubdirs {includepath} {
             } else {
                 if {[file isdir [file tail $path]]} {set path [file tail $path]; lappend retpath $path}
             }
-            #puts "replacing path $path"
         }
         update
         set subdirs ""
@@ -110,7 +106,6 @@ proc ::tcc4tcl::getsubdirs {includepath} {
             set subdirs [glob -nocomplain -directory $path -types d *]
         }
         foreach sub $subdirs {
-            #puts "got subdir ...$sub..."
             set sub [file tail $sub]
             lappend retpath [file join $path $sub]
             append retpath " [::tcc4tcl::getsubdirs [file join $path $sub]]"
@@ -120,7 +115,6 @@ proc ::tcc4tcl::getsubdirs {includepath} {
 }
 
 proc ::tcc4tcl::searchDir {dir inDir} {
-        #puts "Searching $dir in $inDir"
         set subdirs ""
         if {$dir==$inDir} {
             return $inDir
@@ -129,13 +123,11 @@ proc ::tcc4tcl::searchDir {dir inDir} {
             set subdirs [glob -nocomplain -directory $inDir -types d *]
         }
         foreach sub $subdirs {
-            #puts "got subdir ...$sub..."
             if {[file tail $sub]==$dir} {
                 return $sub
             }
         }
         foreach sub $subdirs {
-             #puts "search subdir ...$sub..."
              set d [::tcc4tcl::searchDir $dir $sub]
              if {$d!=""} {
                 return $d
@@ -145,7 +137,6 @@ proc ::tcc4tcl::searchDir {dir inDir} {
 }
 
 proc ::tcc4tcl::shortenpath {path {prefix ""}} {
-    #
     set shortincludepath ""
     if {$prefix==""} {
         set prefix $::tccenv::pathprefix/
@@ -153,7 +144,6 @@ proc ::tcc4tcl::shortenpath {path {prefix ""}} {
     set prefix1 ${prefix}lib/
     set prefix2 ${prefix}lib/tcc4tcl-0.30/
     
-    #puts "Analysing $path"
     set shortresult ""
     set shortpath [string map [list $prefix ""] $path]
     set shortpath1 [string map [list $prefix1 ""] $path] 
@@ -176,7 +166,6 @@ proc ::tcc4tcl::analyse_includes {handle {prefix ""}} {
     set prefix2 ${prefix}lib/tcc4tcl-0.30/
     
     foreach path $usedpath {
-        #puts "Analysing $path"
         set shortpath [string map [list $prefix ""] $path]
         set shortpath1 [string map [list $prefix1 ""] $path] 
         set shortpath2 [string map [list $prefix2 ""] $path] 
@@ -276,7 +265,6 @@ proc ::tcc4tcl::prepare_compilerdirectives {filepath handle} {
     # $compilertype      can be gccwin32/gcclin64/tccwin32/tcclin64/user   and defines prebuilt ccOptions to use; set to user to have no predefined options
     puts "Making Directives for $filepath ($::tccenv::tccmaindir)" 
     set pathway [::tcc4tcl::analyse_includes $handle]
-    #puts "Paths: $pathway"
     set includestccwin32 "-Iinclude -Iinclude/stdinc -Iinclude/generic -Iinclude/generic/win -Iinclude/xlib -Iwin32 -Iwin32/winapi "
     set includesgccwin32 "-Iinclude -Iinclude/generic -Iinclude/generic/win -Iinclude/xlib"
     set includestcclin64 "-Iinclude -Iinclude/stdinc -Iinclude/generic -Iinclude/generic/unix -Iinclude/xlib "
@@ -299,7 +287,6 @@ proc ::tcc4tcl::prepare_compilerdirectives {filepath handle} {
     set includes_generic ""
     
     foreach incpath $pathway {
-        #puts "include $incpath relTo $::tccenv::tccmaindir --> [relTo $incpath $::tccenv::tccmaindir]"
         if {[string first include/ [string tolower $incpath]]<0} {
             if {[string first win32 [string tolower $incpath]]<0} {
                 lappend includes_generic "-I[relTo $incpath $::tccenv::tccmaindir]"
@@ -447,17 +434,12 @@ proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packagevers
     # beautify code
     set mycode [::tcc4tcl::reformat [string map [list [eol] \n] $mycode] 4]
     set $state(type) $oldtype
-    #puts [$handle add_include_path] 
     
     set filename [file join $filepath "$packagename.c"]
     set ccdirectives [::tcc4tcl::prepare_compilerdirectives $filename $::tsp::TCC_HANDLE]
     set fp [open $filename w]
     puts $fp "/***************** Automatically Created with TCC4TCL Helper and maybe TSP **********************************/"
     puts $fp "/* Compiler directives are raw estimates, please adapt to given pathstructure */\n"
-    #puts $fp "/* $tcc_compile  */\n"
-    #puts $fp "/* $gcc_compile */\n"
-    #puts $fp "/* $cross_compile  */\n"
-    #puts $fp "/* $lin64_compile  */\n"
     foreach {compiler ccdirective} $ccdirectives {
         puts $fp "/* for $compiler use */"
         puts $fp "/* $ccdirective */\n"
@@ -550,120 +532,3 @@ proc ::tcc4tcl::reformat {tclcode {pad 4}} {
 }
 
 #----------------------------------- remove this code in future versions -----------------------
-proc ::tcc4tcl::____analyse_codeincludes {fromfile code includepath mdone {usedpath ""}} {
-    # a simple (too simple) routine to find all include files and their paths recursivly
-    # unable to parse any kind of ifdef ifndef
-    # so will mostly try to find ANY file thats behind an #include directive
-    
-    variable done
-    variable includes_missing
-    #puts "Analysing ... $fromfile"
-    update
-    set done $mdone
-    set cinc 0
-    set includer "#include"
-    set rgincluder "#(\\s*)include"
-    set lines [split $code \n]
-    foreach line $lines {
-        #set pos [string first $includer [string tolower $line]]
-        set pos [regexp -nocase $rgincluder $line]
-        if {$pos>0} {
-            # found includer
-            set line [string range $line $pos end]
-            set rest [string range $line [string length $includer] end]
-            set start [string first "\"" $rest]
-            set end [string first "\"" $rest $start+1]
-            if {$start==-1} {
-                set start [string first "<" $rest]
-                set end [string first ">" $rest $start+1]
-            }
-            set filename [string trim [string range $rest $start+1 $end-1]]
-            if {$filename==""} {
-                continue
-            }
-            if {[lsearch $done $filename]==-1} {
-                while {[string range $filename 0 2] eq "../"} {
-                    set filename [string range $filename 3 end]
-                }
-                #puts "Searching ...$filename..."
-                #update
-                set undone 1
-                foreach path $includepath {
-                    if {[file exists [file join $path $filename]]} {
-                        set undone 0
-                        lappend done $filename
-                        lappend usedpath $path
-                        if {[file tail $filename]!=$filename} {
-                            #lappend done [file tail $filename]
-                            lappend usedpath [file join $path [file dir $filename]]
-                            #puts "Found $filename (adding [file join $path [file dir $filename]] and [file tail $filename])"
-                        }
-                        set fp [open [file join $path $filename]]
-                        set codenew [read $fp]
-                        close $fp
-                        #puts "found [file join $path $filename]"
-                        incr cinc
-                        set usedpath [analyse_codeincludes $filename $codenew $includepath $done $usedpath]
-                    } 
-                }
-                if {$undone>0} {
-                    #puts "Not found include  $fromfile -> $filename";
-                    lappend includes_missing $fromfile $filename
-                    lappend done $filename
-                }
-            }
-        }
-    }
-    return [lsort -unique $usedpath]
-}
-
-proc ::tcc4tcl::____makefileglob {includepath {filelist {}} {subdirs 1}} {
-    # create a filelist withh every file in every subpath as a lookup table
-    foreach path $includepath {
-        #puts "Searching $path"
-        set files [glob -tails -nocomplain -directory $path *.{h,c}]
-        foreach file $files {
-            lappend filelist $file $path
-        }
-        if {$subdirs>0} {
-            set subpaths [glob -nocomplain -directory $path -types d *]
-            set filelist [::tcc4tcl::makefileglob $subpaths $filelist $subdirs]
-        }
-    }
-    return $filelist
-}
-
-proc ::tcc4tcl::____commonsubdir {d1 d2} {
-    # returns a list of three
-    # common dirpath
-    # rest of dir1
-    # rest of dir2
-    
-    set d1 [split [string map {\\ /} $d1] /]
-    set d2 [split [string map {\\ /} $d2] /]
-    set l1 [llength $d1]
-    set l2 [llength $d2]
-    if {$l1>$l2} {
-        # swap d1 d2
-        set d $d1
-        set d1 $d2
-        set d2 $d
-        set l1 $l2
-    }
-    set outlist {}
-    for {set i 0} {$i< $l1} {incr i} {
-        if {[lindex $d1 $i]==[lindex $d2 $i]} {
-            lappend outlist [lindex $d1 $i]
-        } else {
-            break;
-        }
-    }
-    set rest1 [lrange $d1 $i end]
-    set rest2 [lrange $d2 $i end]
-        
-    return [list [join $outlist /]/ [join $rest1 /] [join $rest2 /]]
-}
-
-
-
-
diff --git a/tests/test_tsp.tcl b/tests/test_tsp.tcl
new file mode 100644
index 0000000..431c145
--- /dev/null
+++ b/tests/test_tsp.tcl
@@ -0,0 +1,101 @@
+package require tsp
+#tsp::debug ./dbg
+
+#::tsp::init_package testpkg
+tsp::proc fib0 {n} {
+	#tsp::procdef int -args int
+	#tsp::int fib_2 fib_1
+	if {$n < 2} {return 1}
+	#tsp::volatile fib_2
+         set fib_2 [fib [expr {$n -2}]]
+         set fib_1 [fib [expr {$n -1}]]
+	set result [expr {$fib_2 + $fib_1}]
+	return $result
+}
+tsp::proc fib {n} {
+	#tsp::procdef int -args int
+	#tsp::int fib_2 fib_1
+	if {$n < 2} {return 1}
+        set fib_2 [fib [expr {$n -2}]]
+        set fib_1 [fib [expr {$n -1}]]
+	set result [expr {$fib_2 + $fib_1}]
+	return $result
+}
+
+tsp::proc wordsplit {str} {
+	#tsp::procdef var -args string
+	#tsp::var list char
+	#tsp::string word
+	#tsp::boolean is_space
+	#tsp::int strlen len i
+	set list {}
+	set word {}
+        set strlen [string length $str]
+	for {set i 0} {$i < $strlen} {incr i} {
+                set char [string index $str $i]
+		set is_space [string is space $char]
+		if {$is_space} {
+			set len [string length $word]
+			if {$len > 0} {
+				lappend list $word
+			}
+			set word {}
+		} else {
+			append word $char
+		}
+	}
+	set len [string length $word]
+	if {$len > 0} {
+		lappend list $word
+	}
+	return $list
+}
+
+
+tsp::proc foo {} { 
+        #tsp::procdef var
+        #tsp::var ll ll2 
+        set ll {}
+        set ll2 {}
+        puts "ok";
+        set a "test"
+        puts "ok for $a"
+        set ll [list 0 8 7 1 2 3]
+        set ll2 [lsort $ll]
+        #set ll $ll2; # this will crash in execution, due to DecrRef/incrRef error...
+        foreach buf $ll2 {
+            puts $buf
+        }
+        puts "ok $ll2"
+        return "ok"
+}
+# ::tsp::printLog
+#::tsp::finalize_package
+
+proc run_fib {} {
+    set i 0
+    while {$i <= 30} {
+	    puts "n=$i => [fib $i]"
+	    incr i
+    }
+}
+
+proc fib2 {n} {
+	if {$n < 2} {return 1}
+        set fib_2 [fib2 [expr {$n -2}]]
+        set fib_1 [fib2 [expr {$n -1}]]
+	set result [expr {$fib_2 + $fib_1}]
+	return $result
+}
+
+proc run_fib2 {} {
+    set i 0
+    while {$i <= 30} {
+	    puts "n=$i => [fib2 $i]"
+	    incr i
+    }
+}
+#
+
+
+
diff --git a/tsp-clang.tcl b/tsp-clang.tcl
index 18f4d1b..752701b 100755
--- a/tsp-clang.tcl
+++ b/tsp-clang.tcl
@@ -1,25 +1,12 @@
 ##################################################################
 
 # language specific procs - c
-#package require tcc4tcl
 package require tcc4tcl
 
 # FIXME - strings and string command impls should use Tcl_UniChar arrays, not
 #         UTF-8 strings.  
 
 
-# FIXME
-# for testing, set cache dir and clear cache once
-# this is ordinarily in ::tsp::lang_compile
-#::critcl::cache ./.critcl
-#::critcl::clean_cache
-
-
-# force critcl to load so we can capture the original PkgInit bodhy
-#catch {::critcl::cproc}
-#variable ::tsp::critcl_pkginit [info body ::critcl::PkgInit]
-
-
 # BUILTIN_TCL_COMMANDS
 # interpreter builtin commands that we can call directly
 # note: this is all compiled commands, since some tsp_compiled
@@ -1129,24 +1116,21 @@ proc ::tsp::lang_create_compilable {compUnitDict code} {
     regsub -all {\n *$} $cleanup_defs "\n" cleanup_defs
     regsub -all {\n} $cleanup_defs "\\\n" cleanup_defs
     
-# patch for native compiled routines, that don't need pushcallframe/popcallframe
-set popcf ""
-set pushcf "/* Native proc, no external variables used, dropping PushCallframe/PopCallframe */"
-
-if {[dict get $compUnit isNative]==0} { 
-    set pushcf {
-    /* Tcl_CallFrame is dangerous since it is buried deep in the tcl_internals stubs table */
-    /* could easily break in future TCL_VERSION versions */
-    /* Made it functional against 8.6.6 with no guarantee */
-    frame = (Tcl_CallFrame*) ckalloc(sizeof(Tcl_CallFrame));
-    Tcl_PushCallFrame(interp, frame, Tcl_GetGlobalNamespace(interp), 1);
-    }
-    set popcf "    Tcl_PopCallFrame(interp); \\\n    ckfree((char*) frame) \n"
-    #puts "$name is NOT a native proc"
-} else {
-    #puts "$name is a native proc"
-}
-
+    # patch for native compiled routines, that don't need pushcallframe/popcallframe
+    #   /* Tcl_CallFrame is dangerous since it is buried deep in the tcl_internals stubs table */
+    #   /* could easily break in future TCL_VERSION versions */
+    #   /* Functional against 8.6.6 with no guarantee */
+    
+    set popcf ""
+    set pushcf "/* Native proc, no external variables used, dropping PushCallframe/PopCallframe */"
+    
+    if {[dict get $compUnit isNative]==0} { 
+        set pushcf {
+            frame = (Tcl_CallFrame*) ckalloc(sizeof(Tcl_CallFrame));
+            Tcl_PushCallFrame(interp, frame, Tcl_GetGlobalNamespace(interp), 1);
+        }
+        set popcf "    Tcl_PopCallFrame(interp); \\\n    ckfree((char*) frame) \n"
+    } 
 
     append cleanup_defs $popcf
 
@@ -1219,15 +1203,6 @@ if {$::tsp::PACKAGE_HEADER eq ""} {
     #include "TSP_cmd.c"
     #include "TSP_func.c"
     #include "TSP_util.c"
-
-    #define __i386__ 1
-    #if defined(__i386__)
-    // FPU control word for rounding to nearest mode
-    unsigned short __tcc_fpu_control = 0x137f;
-    // FPU control word for round to zero mode for int conversion
-    unsigned short __tcc_int_fpu_control = 0x137f | 0x0c00;
-    #endif
-    
     }
 }
 
@@ -1343,13 +1318,6 @@ $arg_cleanup_defs
 }
 # end of cfileTemplate1
 
-
-
-
-    # defined by critcl::ccomand
-    #   int TSP_UserCmd_${name}(ClientData clientData, Tcl_Interp* interp, int objc, Tcl_Obj *const objv\[\]) 
-
-
     set cfileTemplate2 \
 {
 
@@ -1395,10 +1363,6 @@ $arg_cleanup_defs
 }
 # end of cfileTemplate2
 
-    # critcl needs two pieces, one for ccode and another form ccommand, so return as a list
-
-    #puts [subst $cfileTemplate2]
-
     return [list [subst $cfileTemplate1] [subst $cfileTemplate2]]
 }
 
@@ -1417,37 +1381,8 @@ proc ::tsp::lang_compile {compUnitDict code} {
     set name [dict get $compUnit name]
     variable ::tsp::cc_output 
     set ::tsp::cc_output ""
-    set results ""
+    set __result ""
     set rc [catch {
-        # debugging critcl
-        #::critcl::config lines 0
-        #::critcl::config keepsrc 1
-        #::critcl::cache ./.critcl
-
-# for testing, this is executed on startup, 
-# uncomment for non-dev
-        #::critcl::clean_cache
-
-        # redefine internal critcl print to capture error messages
-        #::proc ::critcl::print {args} {
-        #    append ::tsp::cc_output [lindex $args end]
-        #}
-
-        # redefine internal critcl PkgInit to return a custom package name, becomes
-        # the package init 
-        #::proc ::critcl::PkgInit {file} [list return Tsp_user_[string tolower $name]]
-
-        # tcl 8.5 has wide ints, make that the min version
-        #::critcl::tcl 8.5
-
-        # cause compile to fail if return is not coded in execution branch
-        #if {[regexp gcc [::critcl::targetconfig]]} {
-        #    ::critcl::cflags -Werror=return-type -O3
-        #}
-
-        # create the code, first is the proc (ccode), second is the tcl interface (ccommand)
-        #::critcl::ccode [lindex $code 0]
-        #::critcl::ccommand ::$name {clientData interp objc objv} [lindex $code 1]
         if {$::tsp::COMPILE_PACKAGE==0} {
             set handle [tcc4tcl::new]
             $handle add_include_path "$::tsp::HOME_DIR/native/clang/"
@@ -1462,27 +1397,17 @@ proc ::tsp::lang_compile {compUnitDict code} {
         }
         $handle ccommand "${myns}::$name" {clientData interp objc objv} [lindex $code 1]
 
-	# cause critcl to compile the code and load the resulting .so lib
-        #::critcl::load
         if {$::tsp::COMPILE_PACKAGE==0} {
             set compResult [$handle go]
-            puts $compResult
-            #append ::tsp::cc_output $compResult
             ::tsp::addWarning compUnit "TCC: $compResult"
             dict set compUnit compiledReference tsp.cmd.${name}Cmd
-        } else {
-            #puts "Writing Package deffered"
-        }
-        #puts "Transpiling done"
-    } result ]
-    if {$result ne ""} {
-        puts "Transpile Result: $result"
+        } 
+        unset handle
+    } __result ]
+    if {$__result ne ""} {
+        puts "Transpile Result:\n$__result"
     }
-    #set critcl_results_dict [critcl::cresults]
-    #set critcl_results_dict []
     set errors ""
-#FIXME: use exl key for new critcl version
-    #catch {set errors [dict get [critcl::cresults] log]}
     set cc_errors ""
     foreach line [split $::tsp::cc_output \n] {
         if {[regexp -nocase error $line]} {
@@ -1492,11 +1417,7 @@ proc ::tsp::lang_compile {compUnitDict code} {
     if {$rc || [string length $cc_errors] > 0} {
         ::tsp::addError compUnit "error compiling $name:\n$result\n$errors\n$cc_errors"
     }
-#FIXME: remove reset for new critcl version
-    #catch {critcl::reset}
 
-    # reset the PkgInit proc for other critcl usage
-    #::proc ::critcl::PkgInit {file} $::tsp::critcl_pkginit
     return $rc
 }
 
@@ -1505,7 +1426,6 @@ proc ::tsp::lang_compile {compUnitDict code} {
 # define a compiledReference in the interp
 #
 proc ::tsp::lang_interp_define {compUnitDict} {
-    # this is handled by critcl
     return
 }
 
diff --git a/tsp-compile.tcl b/tsp-compile.tcl
index efa2d2b..176272b 100755
--- a/tsp-compile.tcl
+++ b/tsp-compile.tcl
@@ -162,7 +162,6 @@ proc ::tsp::compile_proc {file name procargs body} {
             ::tsp::logErrorsWarnings compUnit
         } else {
             # parse_body ok, let's see if we can compile it
-            #puts "Generating C-Code\n"
             set compilable [::tsp::lang_create_compilable compUnit $code]
             ::tsp::logCompilable compUnit [join $compilable ""]
             set rc [::tsp::lang_compile compUnit $compilable]
diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index 781f730..1d207cf 100755
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -13,6 +13,7 @@
 # 
 ##############################################################################
 
+package require tcc4tcl
 source [file join [file dirname [info script]] tcc4tcl_helper.tcl]
 
 
@@ -39,7 +40,7 @@ namespace eval ::tsp {
     variable COMPILE_DIRECTIVES ""
     
     # give name of save tcl source here, otherwise we use __lastsaved__.tcl
-    variable ACTSOURCE "__lastsaved__.tcl"
+    variable ACTSOURCE ""
 }
 
 proc ::tsp::hook_proc {} {
@@ -89,8 +90,6 @@ proc ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0}
     set ::tsp::PACKAGE_PROCS ""
     set ::tsp::PACKAGE_INIT_PROC 0
     set ::tsp::TCL_PROCS ""
-    #if {$::tsp::PACKAGE_HEADER eq ""} {
-        # $::tsp::PACKAGE_HEADER gets include from tcc4tcl handle later
     set ::tsp::PACKAGE_HEADER \
         {
 /* START OF PACKAGE_HEADER */
@@ -100,19 +99,8 @@ proc ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0}
 #include "TSP_cmd.c"
 #include "TSP_func.c"
 #include "TSP_util.c"
-
-/* for tcc to work we need some constants defined */
-#define __i386__ 1
-#if defined(__i386__)
-// FPU control word for rounding to nearest mode
-unsigned short __tcc_fpu_control = 0x137f;
-// FPU control word for round to zero mode for int conversion
-unsigned short __tcc_int_fpu_control = 0x137f | 0x0c00;
-#endif
-
 /* END OF PACKAGE_HEADER */
     }
-    #}
     
     $::tsp::TCC_HANDLE add_include_path "$::tsp::HOME_DIR/native/clang/"
     $::tsp::TCC_HANDLE add_include_path $packagename
@@ -157,13 +145,13 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
             set ::tsp::COMPILE_DIRECTIVES [::tcc4tcl::write_packagecode $::tsp::TCC_HANDLE $::tsp::PACKAGE_NAME $tsp::PACKAGE_DIR $::tsp::PACKAGE_VERSION $::tsp::TCL_VERSION]
         }
     }
-    # list with four commandlines, tcc_compile, gcc_compile, cross_compile, lin64_compile
     
     ::tsp::write_pkgAltTcl $::tsp::PACKAGE_NAME
     ::tsp::write_pkgIndex $::tsp::PACKAGE_NAME
     
-    # copy source to package... if already in place, rename
-    if {[file exist $::tsp::ACTSOURCE]} {
+    # if a source file is given
+    # copy source to packagedir... if already in place, rename
+    if {($::tsp::ACTSOURCE ne "")&&[file exist $::tsp::ACTSOURCE]} {
         set t [clock format [clock seconds] -format "%Y-%m-%d_%H-%M-%S"]
         set srcname "${::tsp::PACKAGE_NAME}_tsp_${t}.tcl"
         set srcname [file join $tsp::PACKAGE_DIR $srcname]
@@ -329,9 +317,6 @@ proc ::tsp::test_altpackage {packagename {callcmd ""}} {
         set result [$ip eval source [file join $tsp::PACKAGE_DIR "${packagename}.tclprocs.tcl"]]
         puts "Loading TCL package... $packagename.puretcl.tcl"
         set result [$ip eval source [file join $tsp::PACKAGE_DIR "${packagename}.puretcl.tcl"]]
-
-        #$ip eval  ${packagename}_pkgInit
-        
         if {$callcmd ne ""} {
             puts "Calling $callcmd"
             catch {
@@ -367,9 +352,8 @@ proc ::tsp::rewrite_procnamespace {} {
     set nsprocs ""
     foreach {procname cprocname} $state(procs) {
         if {[lsearch $::tsp::PACKAGE_PROCS [namespace tail $procname]]<0} {
-            # pure c implemented... probs ahead :-)
+            # pure c implemented... there will be no valid TCL representation
             set procdef [list $procname "args" [list puts "Not implemented \"$procname\""]]
-            #puts "found pure c proc $procname, replacing dummy $procdef"
             lappend ::tsp::PACKAGE_PROCS $procname $procdef
             set cdef [dict get $state(procdefs) $procname]
             lassign $cdef cprocname rtype cprocargs
@@ -466,13 +450,11 @@ proc ::tsp::write_pkgIndex {packagename} {
     
     set pkgloadext  "proc ${packagename}_loadext {dir} {\n"
     foreach extdll [lsort -unique $::tsp::LOAD_DLLS] {
-        #
         append pkgloadext "     if {\[catch {load \[file join \$dir $extdll\[info sharedlibextension\]\]} err\]} {\n"
         append pkgloadext "         puts \"Error loading $extdll \$err\"\n"
         append pkgloadext "     }\n"
     }
     foreach exttcl [lsort -unique $::tsp::LOAD_TCLS] {
-        #
         append pkgloadext "     if {\[catch {source  \[file join \$dir ${exttcl}.tcl\]} err\]} {\n" 
         append pkgloadext "         puts \"Error loading $exttcl \$err\"\n"
         append pkgloadext "     }\n"
@@ -519,7 +501,6 @@ proc ::tsp::write_pkgAltTcl {packagename} {
     }
     close $fd
     
-    #::tsp::splice_src  "$::tsp::ACTSOURCE"
     set filename [file join $tsp::PACKAGE_DIR "${packagename}.puretcl.tcl"]
     set fd [open $filename w]
     puts $fd "#  TSP Pure TCL procs for loadlib complemenary procs"
@@ -601,7 +582,6 @@ proc ::tsp::compile_package {packagename {compiler tccwin32}} {
     }
     if {$tsp::PACKAGE_DIR eq ""} {
         puts "No packagedir given, searching in $packagename/$packagename.c"
-        #$tsp::PACKAGE_DIR 
         set filename [file join $tsp::PACKAGE_DIR "$packagename.c"]
         if {![file exists $filename]} {
             set tsp::PACKAGE_DIR $packagename
@@ -752,31 +732,3 @@ proc version:cmdDel {txt line} {
 
 #----------------------------------- Code to remove -----------------------------------------
 
-proc ::tsp::____splice_src {filename} {
-    if {![file exists $filename]} {
-        puts "ERROR: $filename source not found"
-        return -1
-    }
-
-    set f [open "$filename"]
-    set data [read $f]
-    close $f
-    set ::tsp::TCL_PROCS ""
-    foreach {dummy procName} [regexp -all -inline -line {^[\s:]*proc (\S+)} $data] {
-        catch {
-            set procargs ""
-            set _procargs [info args $procName]
-            foreach _procarg $_procargs {
-                if {[info default $procName $_procarg def]>0} {
-                    set _procarg "$_procarg \"$def\""
-                } 
-                lappend procargs $_procarg
-            }
-            set procbody [info body $procName]
-            lappend ::tsp::TCL_PROCS  [list $procName $procargs $procbody]
-        }
-    }
-}
-
-
-

From 16059fe56aaecbc0e7fc0abc7ce2069264c36765 Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Thu, 25 Aug 2022 20:22:58 +0200
Subject: [PATCH 30/39] Add module support for tcc4tcl -Fix hook_proc to only
 note internal procs (not sourced ones) -Add support for tcc4tcl::tclwraps
 module scope interp

---
 tsp-packagehelper.tcl | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index 1d207cf..7edfcff 100755
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -41,14 +41,22 @@ namespace eval ::tsp {
     
     # give name of save tcl source here, otherwise we use __lastsaved__.tcl
     variable ACTSOURCE ""
+    
+    variable _HOOK_LEVEL 0
 }
 
-proc ::tsp::hook_proc {} {
+proc ::tsp::hook_proc {level} {
     # we hook the proc construct to get information about package defined procs
+    variable _HOOK_LEVEL
+    set _HOOK_LEVEL $level
     if {[info command ::__proc] eq ""} {
         rename ::proc ::__proc
         ::__proc ::proc {procName procargs procbody} {
-            lappend ::tsp::TCL_PROCS  [list $procName $procargs $procbody]
+            #puts "script [info script] [info level] [info frame]"
+            if {([info script] eq "")&&([info level]==$::tsp::_HOOK_LEVEL)} {
+                lappend ::tsp::TCL_PROCS  [list $procName $procargs $procbody]
+                #puts "Appending $procName"
+            }
             if {[catch {uplevel 0 ::__proc [list $procName $procargs $procbody]} err]} {
                 rename ::proc ""
                 rename ::__proc ::proc
@@ -86,7 +94,7 @@ proc ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0}
     
     catch { unset ::tsp::TCC_HANDLE}
     set ::tsp::TCC_HANDLE [tcc4tcl::new]
-
+    set tcc4tcl::moduleName $packagename
     set ::tsp::PACKAGE_PROCS ""
     set ::tsp::PACKAGE_INIT_PROC 0
     set ::tsp::TCL_PROCS ""
@@ -112,7 +120,7 @@ proc ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0}
     set ::tsp::LOAD_DLLS "" 
     set ::tsp::EXTERNAL_DLLS "" 
     
-    ::tsp::hook_proc
+    ::tsp::hook_proc [info level]
 }
 
 proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
@@ -402,7 +410,7 @@ proc ::tsp::write_pkgIndex {packagename} {
     catch {set tclpr $::tsp::TCL_PROCS}
     foreach tcldef $tclpr {
         lassign $tcldef cproc cvars cbody
-        puts $fd "# $cproc $cvars"
+        puts $fd [string map {\n "."} "# $cproc $cvars"]
     }
     set handle $::tsp::TCC_HANDLE
     set loadextlibs "proc ${packagename}_loadextdlls {dir} {\ncatch {\n"
@@ -573,6 +581,7 @@ proc ::tsp::compile_package {packagename {compiler tccwin32}} {
     if {$ctype==99} {
         puts "Debug Source"
         puts [$::tsp::TCC_HANDLE code]
+        puts "#--End of code---------------------"
         return 1
     }
 

From 21e5d4c8d2e99eb377d6536a65af36b87cb300e3 Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Sat, 27 Aug 2022 10:31:52 +0200
Subject: [PATCH 31/39] Code cleaning

---
 tsp-packagehelper.tcl | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index 7edfcff..f7c0db6 100755
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -52,10 +52,8 @@ proc ::tsp::hook_proc {level} {
     if {[info command ::__proc] eq ""} {
         rename ::proc ::__proc
         ::__proc ::proc {procName procargs procbody} {
-            #puts "script [info script] [info level] [info frame]"
             if {([info script] eq "")&&([info level]==$::tsp::_HOOK_LEVEL)} {
                 lappend ::tsp::TCL_PROCS  [list $procName $procargs $procbody]
-                #puts "Appending $procName"
             }
             if {[catch {uplevel 0 ::__proc [list $procName $procargs $procbody]} err]} {
                 rename ::proc ""
@@ -94,7 +92,7 @@ proc ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0}
     
     catch { unset ::tsp::TCC_HANDLE}
     set ::tsp::TCC_HANDLE [tcc4tcl::new]
-    set tcc4tcl::moduleName $packagename
+
     set ::tsp::PACKAGE_PROCS ""
     set ::tsp::PACKAGE_INIT_PROC 0
     set ::tsp::TCL_PROCS ""
@@ -581,7 +579,6 @@ proc ::tsp::compile_package {packagename {compiler tccwin32}} {
     if {$ctype==99} {
         puts "Debug Source"
         puts [$::tsp::TCC_HANDLE code]
-        puts "#--End of code---------------------"
         return 1
     }
 

From 19e4b4284c27fc5a576f8b9f1c0f9b6c5a5ba50e Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Sat, 22 Oct 2022 18:40:22 +0200
Subject: [PATCH 32/39] Add basic support for array indexing supports the forms
 a(b) and a($b) preliminary, needs testing

---
 tsp-clang.tcl        |   8 ++--
 tsp-generate-set.tcl | 104 +++++++++++++++++++++++++++++++++++++++----
 2 files changed, 100 insertions(+), 12 deletions(-)

diff --git a/tsp-clang.tcl b/tsp-clang.tcl
index 752701b..1c6461a 100755
--- a/tsp-clang.tcl
+++ b/tsp-clang.tcl
@@ -567,13 +567,14 @@ proc ::tsp::lang_assign_empty_zero {var type} {
 #
 proc ::tsp::lang_assign_var_array_idxvar {targetObj arrVar idxVar errMsg} {
     append result "/* ::tsp::lang_assign_var_array_idxvar */\n"
-
+    append result "[::tsp::lang_safe_release $targetObj]"
     append result "$targetObj = Tcl_ObjGetVar2(interp, $arrVar, $idxVar, TCL_LEAVE_ERR_MSG);\n"
     append result "if ($targetObj == NULL) \{\n"
     append result "    /* Tcl_AppendResult(interp, [::tsp::lang_quote_string $errMsg], (char *) NULL);*/\n"
     append result "    *rc = TCL_ERROR;\n"
     append result "    ERROR_EXIT;\n"
     append result "\}\n"
+    append result "[::tsp::lang_preserve $targetObj]"
     return $result
 }
 
@@ -584,15 +585,14 @@ proc ::tsp::lang_assign_var_array_idxvar {targetObj arrVar idxVar errMsg} {
 #
 proc ::tsp::lang_assign_var_array_idxtext {targetObj arrVar idxTxtVar errMsg} {
     append result "/* ::tsp::lang_array_get_array_idxtext */\n"
-
+    append result "[::tsp::lang_safe_release $targetObj]"
     append result "$targetObj = Tcl_ObjGetVar2(interp, $arrVar, $idxTxtVar, TCL_LEAVE_ERR_MSG);\n"
     append result "if ($targetObj == NULL) \{\n"
     append result "    /* Tcl_AppendResult(interp, [::tsp::lang_quote_string $errMsg], (char *) NULL);*/\n"
     append result "    *rc = TCL_ERROR;\n"
     append result "    ERROR_EXIT;\n"
     append result "\}\n"
-    return $result
-
+    append result "[::tsp::lang_preserve $targetObj]"
     return $result
 }
 
diff --git a/tsp-generate-set.tcl b/tsp-generate-set.tcl
index 8dea751..48bb7b0 100755
--- a/tsp-generate-set.tcl
+++ b/tsp-generate-set.tcl
@@ -671,18 +671,106 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
                 set sourceCmdRange [lindex $component 2]
                 lassign [::tsp::parse_nestedbody compUnit $sourceCmdRange] sourceType sourceRhsVar sourceCode
     
-	        if {$sourceCode eq ""} {
-		    ::tsp::addError compUnit "assignment from nested command: no code generated: target \"$targetVarName\" "
-		    return [list void "" ""]
+                if {$sourceCode eq ""} {
+                    ::tsp::addError compUnit "assignment from nested command: no code generated: target \"$targetVarName\" "
+                    return [list void "" ""]
+                }
+        
+                if {$sourceType eq "void"} {
+                    ::tsp::addError compUnit "void assignment from nested command: target \"$targetVarName\""
+                    return [list void "" ""]
                 }
-    
-	        if {$sourceType eq "void"} {
-		    ::tsp::addError compUnit "void assignment from nested command: target \"$targetVarName\""
-		    return [list void "" ""]
-	        }
                 append code $sourceCode
                 append code [::tsp::gen_assign_scalar_scalar compUnit $tmp string $sourceRhsVar $sourceType ]
             }
+            text_array_idxvar - array_idxvar {
+                 append code "//Parsing Array $compType in $component of $sourceComponents\n"
+                 #::tsp::addWarning compUnit "$compType not implemented $component $sourceComponents"
+                 #append code "// Parsing $component in $sourceComponents\n"
+				set tmp_s [::tsp::get_tmpvar compUnit string]
+				set doreturn 0
+
+                # assignment from native variable or var, possible type coersion
+                set sourceVarName [lindex $component 2]
+                #append code "// assignment  |$sourceVarName| to $tmp_s\n"
+                set sourceType [::tsp::getVarType compUnit $sourceVarName]
+                if {$sourceType eq "undefined"} {
+                    ::tsp::addError compUnit "set command arg 2 interpolated string variable not defined: \"$sourceVarName\""
+                    return [list ""]
+                }
+                append code [::tsp::gen_assign_scalar_scalar compUnit $tmp_s string $sourceVarName $sourceType]
+
+				if {($compType=="array_idxvar")} {
+					#::tsp::addWarning compUnit "set arg 2 interpolated string cannot contain $compType as $component in $sourceComponents, only commands, text, backslash, or scalar variables"
+					set tmp_a [::tsp::get_tmpvar compUnit var tmp_array]
+					set tmp_v [::tsp::get_tmpvar compUnit var tmp_idx]
+					append code [::tsp::lang_assign_var_string $tmp_v $tmp_s]
+					# append code "// Convert array |$tmp_a| to $tmp\n"
+                     append code [::tsp::lang_assign_var_array_idxvar $tmp_a [::tsp::get_constvar [::tsp::getConstant compUnit [lindex $component 1]]] $tmp_v "Error loading Array Text"]
+					append code [::tsp::lang_convert_string_var $tmp $tmp_a]
+				} else {
+				    set sourceText [lindex $sourceComponents 3]
+				    if {$sourceText eq ""} {
+				        append code "//Missing source in $sourceComponents\n"
+				        continue
+				    } else {
+                        #::tsp::addWarning compUnit "set arg 2 interpolated string should not contain $compType as $sourceText in $sourceComponents, only commands, text, backslash, or scalar variables\n"
+                        set newsource "[lindex $sourceComponents 1]("
+                        #append code "// Convert |$newsource|  to $tmp via $tmp_s\n"
+                        append code [::tsp::lang_assign_string_const $tmp $newsource]
+                        append code [::tsp::lang_append_string $tmp $tmp_s]
+                        append code "Tcl_DStringAppend($tmp,\")\",-1);\n"
+                        set doreturn 1
+                    }
+				}
+				if {$targetType eq "string"} {
+					#append code "// Append string |$tmp|\n"
+					append code [::tsp::lang_append_string $targetPre$targetVarName $tmp]
+				} elseif {$targetType eq "var"} {
+					#append code "// Append var |$tmp|\n"
+					append code [::tsp::lang_assign_var_string $targetVarName $tmp]
+				}
+				#append code [::tsp::lang_assign_empty_zero $tmp string]
+				if {$doreturn>0} {
+				    append code "// exiting\n"
+					return $code
+				}
+            }
+            text_array_idxtext - array_idxtext {
+                 append code "//Parsing Array $compType in $component of $sourceComponents\n"
+				set tmp_s [::tsp::get_tmpvar compUnit string]
+				set doreturn 0
+				if {($compType=="array_idxtext")} {
+					#::tsp::addWarning compUnit "set arg 2 interpolated string cannot contain $compType as $component in $sourceComponents, only commands, text, backslash, or scalar variables"
+					set tmp_a [::tsp::get_tmpvar compUnit var tmp_array]
+					#append code "// Convert array |$tmp_a| to $tmp\n"
+					append code [::tsp::lang_assign_var_array_idxvar $tmp_a [::tsp::get_constvar [::tsp::getConstant compUnit [lindex $component 1]]] [::tsp::get_constvar [::tsp::getConstant compUnit [lindex $component 2]]] "Error loading Array Text"]
+					append code [::tsp::lang_convert_string_var $tmp $tmp_a]
+				} else {
+				    set sourceText [lindex $sourceComponents 3]
+				    if {$sourceText eq ""} {
+				        append code "//Missing source in $sourceComponents\n"
+				        continue
+				    } else {
+                        #::tsp::addWarning compUnit "set arg 2 interpolated string should not contain $compType as $sourceText in $sourceComponents, only commands, text, backslash, or scalar variables\n"
+                        #append code "// Convert |$sourceText| to $tmp\n"
+                        append code [::tsp::lang_assign_string_const $tmp $sourceText]
+                        set doreturn 1
+                    }
+				}
+				if {$targetType eq "string"} {
+					#append code "// Append string |$tmp|\n"
+					append code [::tsp::lang_append_string $targetPre$targetVarName $tmp]
+				} elseif {$targetType eq "var"} {
+					#append code "// Append var |$tmp|\n"
+					append code [::tsp::lang_assign_var_string $targetVarName $tmp]
+				}
+				#append code [::tsp::lang_assign_empty_zero $tmp string]
+				if {$doreturn>0} {
+				    append code "// exiting\n"
+					return $code
+				}
+            }
             default {
                 ::tsp::addError compUnit "set arg 2 interpolated string cannot contain $compType, only commands, text, backslash, or scalar variables"
                 return ""

From 850be4687a30ffd453b6b1b0c8ca95d750149e50 Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Fri, 7 Apr 2023 11:47:21 +0200
Subject: [PATCH 33/39] Changes affect only helper routines, not the TSP Core

---
 tcc4tcl_helper.tcl    |  24 ++++++---
 tsp-packagehelper.tcl | 114 +++++++++++++++++++++++++++---------------
 2 files changed, 90 insertions(+), 48 deletions(-)

diff --git a/tcc4tcl_helper.tcl b/tcc4tcl_helper.tcl
index 0bdc72b..bd8e523 100644
--- a/tcc4tcl_helper.tcl
+++ b/tcc4tcl_helper.tcl
@@ -163,7 +163,7 @@ proc ::tcc4tcl::analyse_includes {handle {prefix ""}} {
         set prefix $::tccenv::pathprefix/
     }
     set prefix1 ${prefix}lib/
-    set prefix2 ${prefix}lib/tcc4tcl-0.30/
+    set prefix2 ${prefix}lib/tcc4tcl/
     
     foreach path $usedpath {
         set shortpath [string map [list $prefix ""] $path]
@@ -264,7 +264,8 @@ proc ::tcc4tcl::prepare_compilerdirectives {filepath handle} {
     # $exeFile          cc to execute
     # $compilertype      can be gccwin32/gcclin64/tccwin32/tcclin64/user   and defines prebuilt ccOptions to use; set to user to have no predefined options
     puts "Making Directives for $filepath ($::tccenv::tccmaindir)" 
-    set pathway [::tcc4tcl::analyse_includes $handle]
+    set pathway ""
+    catch {set pathway [::tcc4tcl::analyse_includes $handle]}
     set includestccwin32 "-Iinclude -Iinclude/stdinc -Iinclude/generic -Iinclude/generic/win -Iinclude/xlib -Iwin32 -Iwin32/winapi "
     set includesgccwin32 "-Iinclude -Iinclude/generic -Iinclude/generic/win -Iinclude/xlib"
     set includestcclin64 "-Iinclude -Iinclude/stdinc -Iinclude/generic -Iinclude/generic/unix -Iinclude/xlib "
@@ -272,15 +273,15 @@ proc ::tcc4tcl::prepare_compilerdirectives {filepath handle} {
     set includesuser ""
 
     set librariestccwin32 "-ltclstub86elf -ltkstub86elf"
-    set librariestcclin64 "-ltclstub86elf -ltkstub86elf"
+    set librariestcclin64 "-ltclstub86_64 -ltkstub86_64"
     set librariesgccwin32 "-Llib -ltclstub86 -ltkstub86"
     set librariesgcclin64 "-Llib -ltclstub86_64 -ltkstub86_64"
     set librariesuser ""
     
     set ccoptionstccwin32 "-m32 -D_WIN32 "
     set ccoptionsgccwin32 "-s -m32 -D_WIN32 -static-libgcc "
-    set ccoptionstcclin64 ""
-    set ccoptionsgcclin64 "-s -fPIC -D_GNU_SOURCE "
+    set ccoptionstcclin64 {-Wl,-rpath='.'}
+    set ccoptionsgcclin64 {-s -fPIC -D_GNU_SOURCE -Wl,-rpath=. }
     
     set ccoptionstccuser ""
     
@@ -296,8 +297,14 @@ proc ::tcc4tcl::prepare_compilerdirectives {filepath handle} {
     
     set libraries_addon ""
     lappend libraries_addon "-Llib"
+    set libps ""
+    set libs ""
+    set opts ""
+    catch {
     set libps [$handle add_library_path]
     set libs [$handle add_library]
+    set opts [$handle add_options]
+    }
     foreach inclib $libs {
         lappend libraries_addon "-l$inclib"
     }
@@ -342,9 +349,10 @@ proc ::tcc4tcl::prepare_compilerdirectives {filepath handle} {
         set ccpath [file join $exeDir $exeFile]
         append ccoptions " -shared -DUSE_TCL_STUBS -O2"
         append ccOptions " $ccoptions"
+        append ccOptions " [join $opts { }]"
         
-        puts "Directive for $compiler"
-        puts "$ccpath $ccOptions $includes $includes_generic $cfile -o$ofile $libraries"
+        #puts "Directive for $compiler"
+        #puts "$ccpath $ccOptions $includes $includes_generic $cfile -o$ofile $libraries"
         lappend ccdirectives $compiler "$ccpath $ccOptions $includes $includes_generic $cfile -o$ofile $libraries"
     }
     return $ccdirectives
@@ -406,7 +414,7 @@ proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packagevers
 #   define DLLIMPORT __declspec(dllimport)
 #   define DLLEXPORT __declspec(dllexport)
 #else
-#   define DLLIMPORT __attribute__(dllimport)
+#   define DLLIMPORT 
 #   if defined(__GNUC__) && __GNUC__ > 3
 #       define DLLEXPORT __attribute__ ((visibility(\"default\")))
 #   else
diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index f7c0db6..e40e358 100755
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -212,18 +212,25 @@ proc ::tsp::add_dllinclude {fname} {
     lappend ::tsp::EXTERNAL_DLLS $fname
 }
 
-proc ::tsp::test_packageX {packagename {callcmd ""} {shell "./tclkit_866_3.upx.exe"}} {
-    # ok, now things really get difficult, if the directory structure doesn't work
+proc ::tsp::test_packageX {packagename {callcmd ""} {shell "./tclkit_8.6.12.exe"}} {
+    # ok, now things really get difficult, if the directory structure doesn't work "./tclkit_866_3.upx.exe"
     # this actually only works under windows, you need a tclkit named $shell in the current working dir
     set result "failed testloading package $packagename"
     set callresult ""
+    set packagedir [file dir $packagename]
+    set packagename [file tail $packagename]
     puts "Testing package $packagename"
     if {[catch {
         puts "Creating new exec"
         set fd [open resrc.tcl w]
-        puts "appending auto_path with [file dir $tsp::PACKAGE_DIR]"
+        puts $fd "#!/usr/bin/tclsh"
         puts $fd "catch {console show}"
+        puts "appending auto_path with [file dir $tsp::PACKAGE_DIR]"
         puts $fd "lappend auto_path [file dir $tsp::PACKAGE_DIR]"
+        if {[file dir $tsp::PACKAGE_DIR] ne $packagedir} {
+            puts "appending auto_path with $packagedir"
+            puts $fd "lappend auto_path $packagedir"
+        }
         puts "Loading package... $packagename"
         puts $fd "package require $packagename"
         
@@ -238,43 +245,56 @@ proc ::tsp::test_packageX {packagename {callcmd ""} {shell "./tclkit_866_3.upx.e
     puts "Go"
     
     # shell actually hardcoded... todo implement some clever routine to find nearest kit
-    
-    if {[catch {
-        if {![file exists $shell]} {
-            puts "Shell not found $shell... searching"
-            # mark your shells as tclkit-8.6.6.exe to get found 866 8-6-6 all will do
-            # this will search for 8.6.6 shell
-            # or at least any 8.6 shell
-            set flist [glob tclkit*.exe]
-            set cand ""
-            foreach kit $flist {
-                set vnum [join [regexp -all -inline "\[0-9\]" $kit]]
-                set vstring2 [join [lrange $vnum 0 1] "."]
-                set vstring3 [join [lrange $vnum 0 2] "."]
-                if {$vstring2 eq "8.6"} {
-                    lappend cand $kit $vstring3
+    # and to run under linux
+    if {$::tcl_platform(platform)=="unix"} {
+        puts "Seems to be a native linux, calling tclsh"
+        #exec >@stdout tclsh resrc.tcl
+        # solution:
+        set runcmd [list exec tclsh resrc.tcl 2>@stderr]
+        
+        if {[catch $runcmd res]} {
+          error "Failed to run command $runcmd: $res"
+        }
+        
+        puts $res
+    } else {
+        if {[catch {
+            if {![file exists $shell]} {
+                puts "Shell not found $shell... searching"
+                # mark your shells as tclkit-8.6.6.exe to get found 866 8-6-6 all will do
+                # this will search for 8.6.6 shell
+                # or at least any 8.6 shell
+                set flist [glob tclkit*.exe]
+                set cand ""
+                foreach kit $flist {
+                    set vnum [join [regexp -all -inline "\[0-9\]" $kit]]
+                    set vstring2 [join [lrange $vnum 0 1] "."]
+                    set vstring3 [join [lrange $vnum 0 2] "."]
+                    if {$vstring2 eq "8.6"} {
+                        lappend cand $kit $vstring3
+                    }
+                    if {$vstring3 eq "8.6.6"} {
+                        # found an 866, use it
+                        set shell $kit
+                        puts "found $shell"
+                        break;
+                    }
                 }
-                if {$vstring3 eq "8.6.6"} {
-                    # found an 866, use it
-                    set shell $kit
-                    puts "found $shell"
-                    break;
+                if {[llength $cand]==0} {
+                    puts "Error: Shell not found"
+                    return 
                 }
+                set cand [lsort -decreasing -stride 2 $cand]
+                puts "Candidates $cand"
+                set shell [lindex $cand 0]
+                puts "using $shell"
+                
             }
-            if {[llength $cand]==0} {
-                puts "Error: Shell not found"
-                return 
-            }
-            set cand [lsort -decreasing -stride 2 $cand]
-            puts "Candidates $cand"
-            set shell [lindex $cand 0]
-            puts "using $shell"
-            
-        }
-        exec $shell resrc.tcl &
-    } err]} {
-            puts "Error while preparing package $packagename\n$err"
+            exec $shell resrc.tcl &
+        } err]} {
+                puts "Error while preparing package $packagename\n$err"
         }
+    }
     return 
 }
 
@@ -359,14 +379,20 @@ proc ::tsp::rewrite_procnamespace {} {
     foreach {procname cprocname} $state(procs) {
         if {[lsearch $::tsp::PACKAGE_PROCS [namespace tail $procname]]<0} {
             # pure c implemented... there will be no valid TCL representation
-            set procdef [list $procname "args" [list puts "Not implemented \"$procname\""]]
-            lappend ::tsp::PACKAGE_PROCS $procname $procdef
+            ##set procdef [list $procname "args" [list puts "Not implemented \"$procname\""]]
+            ##lappend ::tsp::PACKAGE_PROCS $procname $procdef
             set cdef [dict get $state(procdefs) $procname]
             lassign $cdef cprocname rtype cprocargs
             set procargs ""
+            set procargsfull ""
             foreach {ctype vname} $cprocargs {
                 lappend procargs $ctype
+                if {$vname!= "interp"} {
+                    lappend procargsfull $vname
+                }
             }
+            set procdef [list $procname "$procargsfull" [list puts "Not implemented \"$procname\""]]
+            lappend ::tsp::PACKAGE_PROCS $procname $procdef
             #lappend ::tsp::COMPILED_PROCS $procname [list $rtype $procargs $cprocname]
         }
     }
@@ -412,7 +438,12 @@ proc ::tsp::write_pkgIndex {packagename} {
     }
     set handle $::tsp::TCC_HANDLE
     set loadextlibs "proc ${packagename}_loadextdlls {dir} {\ncatch {\n"
-    append loadextlibs {set appdir [file dir [info nameofexecutable]]}
+    append loadextlibs {
+        switch -- $::tcl_platform(platform) {
+            windows {set appdir [file dir [info nameofexecutable]]}
+            unix {set appdir [file dir [info script]]}
+        }
+    }
     append loadextlibs "\n"
     
     set libs [$handle add_library]
@@ -421,6 +452,9 @@ proc ::tsp::write_pkgIndex {packagename} {
         lappend libs {*}$::tsp::EXTERNAL_DLLS
     }
     foreach incpath $libs {
+        if {![file exists [file join $tsp::PACKAGE_DIR $incpath[info sharedlibextension]]]} {
+            set incpath lib$incpath
+        }
         append loadextlibs "\nset incdll \[file join \$dir $incpath\[info sharedlibextension\]\]\n"
         append loadextlibs "set appdll \[file join \$appdir $incpath\[info sharedlibextension\]\]\n"
         append loadextlibs "if {!\[file exists \$appdll\]} {\n"
@@ -611,7 +645,7 @@ proc ::tsp::compile_package {packagename {compiler tccwin32}} {
     puts "Compiling external $cdirect"
     set  ::errorCode ""
     catch {
-        eval exec $cdirect
+        exec {*}$cdirect
     } err
     cd $wd
     puts "Result:\n$err\n"

From 4c5315d6a896336ddeafd5f260582437c0926b26 Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Mon, 2 Dec 2024 22:09:04 +0100
Subject: [PATCH 34/39] Some small changes, bugfixes and additional features

---
 tcc4tcl_helper.tcl    |  37 ++++++-----
 tsp-clang.tcl         |  10 ++-
 tsp-compile.tcl       |   2 +
 tsp-expr.tcl          |   2 +-
 tsp-generate-math.tcl |   1 -
 tsp-generate-set.tcl  |  31 ++++++---
 tsp-packagehelper.tcl | 150 +++++++++++++++++++++++++++++-------------
 tsp-types.tcl         |   3 +-
 8 files changed, 159 insertions(+), 77 deletions(-)

diff --git a/tcc4tcl_helper.tcl b/tcc4tcl_helper.tcl
index bd8e523..f8759f5 100644
--- a/tcc4tcl_helper.tcl
+++ b/tcc4tcl_helper.tcl
@@ -1,6 +1,6 @@
 package provide tcc4tcl_helper 0.1
 
-namespace eval tccenv {
+namespace eval ::tccenv {
     # some common envelope vars for our ide
     # this tries to analyze the surrounding dirs
     # to find a suitable external compiler
@@ -30,6 +30,23 @@ namespace eval tccenv {
     
     variable EXTERNAL_COMPILERS ""
     variable CC_DIRECTIVES ""
+    variable DLEXPORTMAKRO "
+/***************** DLL EXPORT MAKRO FOR TCC AND GCC ************/
+#if (defined(_WIN32) && (defined(_MSC_VER)|| defined(__TINYC__)  || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x0550)) || defined(__LCC__) || defined(__WATCOMC__) || (defined(__GNUC__) && defined(__declspec))))
+#undef DLLIMPORT
+#undef DLLEXPORT
+#   define DLLIMPORT __declspec(dllimport)
+#   define DLLEXPORT __declspec(dllexport)
+#else
+#   define DLLIMPORT 
+#   if defined(__GNUC__) && __GNUC__ > 3
+#       define DLLEXPORT __attribute__ ((visibility(\"default\")))
+#   else
+#       define DLLEXPORT
+#   endif
+#endif
+/***************************************************************/
+"        
     
     # the following routines try to find tcc.exe and gcc.exe under win32 and set the tccenv vars accordingly
     
@@ -406,23 +423,7 @@ proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packagevers
         }
     }
 
-        set DLEXPORTMAKRO "
-/***************** DLL EXPORT MAKRO FOR TCC AND GCC ************/
-#if (defined(_WIN32) && (defined(_MSC_VER)|| defined(__TINYC__)  || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x0550)) || defined(__LCC__) || defined(__WATCOMC__) || (defined(__GNUC__) && defined(__declspec))))
-#undef DLLIMPORT
-#undef DLLEXPORT
-#   define DLLIMPORT __declspec(dllimport)
-#   define DLLEXPORT __declspec(dllexport)
-#else
-#   define DLLIMPORT 
-#   if defined(__GNUC__) && __GNUC__ > 3
-#       define DLLEXPORT __attribute__ ((visibility(\"default\")))
-#   else
-#       define DLLEXPORT
-#   endif
-#endif
-/***************************************************************/
-"        
+    set DLEXPORTMAKRO $::tccenv::DLEXPORTMAKRO
     upvar #0 $handle state
     set oldtype "package"
     if {$state(type)!="package"} {
diff --git a/tsp-clang.tcl b/tsp-clang.tcl
index 1c6461a..f7a4f5d 100755
--- a/tsp-clang.tcl
+++ b/tsp-clang.tcl
@@ -134,6 +134,7 @@ proc ::tsp::lang_type_null {} {
 # declare a native boolean
 #
 proc ::tsp::lang_decl_native_boolean {varName} {
+    return "int $varName;\n"
     return "int $varName = 0;\n"
 }
 
@@ -141,6 +142,7 @@ proc ::tsp::lang_decl_native_boolean {varName} {
 # declare a native int
 #
 proc ::tsp::lang_decl_native_int {varName} {
+    return "Tcl_WideInt $varName;\n"
     return "Tcl_WideInt $varName = 0;\n"
 }
 
@@ -148,6 +150,7 @@ proc ::tsp::lang_decl_native_int {varName} {
 # declare a native double
 #
 proc ::tsp::lang_decl_native_double {varName} {
+    return "double $varName;\n"
     return "double $varName = 0;\n"
 }
 
@@ -1161,7 +1164,7 @@ proc ::tsp::lang_create_compilable {compUnitDict code} {
         lassign $proc_info procType procArgTypes procRef
             
         if {$procType eq "void"} {
-            set procNativeType ""
+            set procNativeType "void"
         } else {
             set procNativeType "[::tsp::lang_xlate_native_type $procType] "
         }
@@ -1232,10 +1235,11 @@ TSP_UserDirect_${name}(Tcl_Interp* interp, int* rc  $nativeTypedArgs ) {
     int idx2;
     char* str1;     
     char* str2;     
-    char* exprErrMsg = NULL;
+    char* exprErrMsg ;
+    
     Tcl_Obj* _tmpVar_cmdResultObj = NULL;
 
-    Tcl_CallFrame* frame = NULL; 
+    Tcl_CallFrame* frame; 
 
     $returnVarDecl
     [::tsp::indent compUnit $argObjvArrays 1 \n]
diff --git a/tsp-compile.tcl b/tsp-compile.tcl
index 176272b..f5ca5da 100755
--- a/tsp-compile.tcl
+++ b/tsp-compile.tcl
@@ -88,6 +88,7 @@ proc ::tsp::compile_proc {file name procargs body} {
     set errInf ""
     set rc [ catch {set compileResult [::tsp::parse_body compUnit {0 end}] } errInf] 
     if {$rc != 0} {
+        catch {puts [join [dict get $compUnit errors] \n]}
         error "tsp internal error: parse_body error: $errInf"
     }
 
@@ -110,6 +111,7 @@ proc ::tsp::compile_proc {file name procargs body} {
     # reparse
     set rc [ catch {set compileResult [::tsp::parse_body compUnit {0 end}] } errInf] 
     if {$rc != 0} {
+        catch {puts [join [dict get $compUnit errors] \n]}
         error "tsp internal error: parse_body error: $errInf"
     }
     
diff --git a/tsp-expr.tcl b/tsp-expr.tcl
index 1f7c908..d4db30e 100755
--- a/tsp-expr.tcl
+++ b/tsp-expr.tcl
@@ -587,7 +587,7 @@ proc ::tsp::produce_subexpr {compUnitDict expr tree} {
             set type [::tsp::getVarType compUnit $thingtext]
             set idx [lsearch -exact $::tsp::EXPR_TYPES $type]
             if {$idx == -1} {
-                error "variable \"$thingtext\" not type of boolean, int, double, or string: \"$type\" in expression: $nodeexpr"
+                error "subex variable \"$thingtext\" not type of boolean, int, double, or string: \"$type\" in expression: $nodeexpr"
             }
             # NOTE that we change the variable for native compilation by prefixing with "__"
             set pre [::tsp::var_prefix $thingtext]
diff --git a/tsp-generate-math.tcl b/tsp-generate-math.tcl
index 4f50a85..491acfd 100755
--- a/tsp-generate-math.tcl
+++ b/tsp-generate-math.tcl
@@ -16,7 +16,6 @@ proc ::tsp::gen_command_expr {compUnitDict tree} {
 
     # just get raw text from body
     set rawtext [::tsp::parse_getstring compUnit [lindex $tree 1]]
-
     if { [string range $rawtext 0 0] ne "\{"} {
         ::tsp::addError compUnit "expr argument not a braced expression"
         return [list void "" ""]
diff --git a/tsp-generate-set.tcl b/tsp-generate-set.tcl
index 48bb7b0..e01392b 100755
--- a/tsp-generate-set.tcl
+++ b/tsp-generate-set.tcl
@@ -67,7 +67,7 @@ proc ::tsp::gen_command_set {compUnitDict tree} {
     }
     set targetStr [parse getstring $body [lindex [lindex $tree 1] 1]]
     set sourceStr [parse getstring $body [lindex [lindex $tree 2] 1]]
-
+    #puts "set $targetStr $sourceStr " 
     # check target, should be a single text, text_array_idxtext, or text_array_idxvar
     set targetComponents [::tsp::parse_word compUnit [lindex $tree 1]]
     set firstType [lindex [lindex $targetComponents 0] 0]
@@ -390,7 +390,7 @@ proc ::tsp::produce_set {compUnitDict tree targetComponents sourceComponents} {
 	    # generate assignment
 	    # mostly same as a scalar from scalar assignment
 	    set sourceVarName $sourceRhsVar
-	    append result "\n/***** ::tsp::generate_set assign from command */\n"
+	    append result "\n/***** ::tsp::generate_set assign from command (set $targetVarName = $sourceVarName) */\n"
 	    append code $sourceCode
 	    set targetType [::tsp::gen_check_target_var compUnit $targetVarName $targetType $sourceType]
 	    if {$targetType eq "ERROR"} {
@@ -640,7 +640,8 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
     set targetPre [::tsp::var_prefix $targetVarName]
 
     append result "\n/***** ::tsp::gen_assign_var_string_interpolated_string */\n"
-
+    
+    
     set tmp [::tsp::get_tmpvar compUnit string]
     set tmp2 ""
     set arrVar ""
@@ -648,6 +649,13 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
         set tmp2 [::tsp::get_tmpvar compUnit string]
         append result [::tsp::lang_assign_empty_zero $tmp2 string]
     }
+    # fix: why is this not reset?
+    if {$targetType eq "string"} {
+        if {$targetPre!=""} {
+            append result  "Tcl_DStringSetLength($targetPre$targetVarName,0);\n"
+        }
+    }
+        
     foreach component $sourceComponents {
         set compType [lindex $component 0]
         switch $compType {
@@ -684,6 +692,7 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
                 append code [::tsp::gen_assign_scalar_scalar compUnit $tmp string $sourceRhsVar $sourceType ]
             }
             text_array_idxvar - array_idxvar {
+                puts "//Parsing Array $compType in $component of $sourceComponents\n"
                  append code "//Parsing Array $compType in $component of $sourceComponents\n"
                  #::tsp::addWarning compUnit "$compType not implemented $component $sourceComponents"
                  #append code "// Parsing $component in $sourceComponents\n"
@@ -705,8 +714,8 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
 					set tmp_a [::tsp::get_tmpvar compUnit var tmp_array]
 					set tmp_v [::tsp::get_tmpvar compUnit var tmp_idx]
 					append code [::tsp::lang_assign_var_string $tmp_v $tmp_s]
-					# append code "// Convert array |$tmp_a| to $tmp\n"
-                     append code [::tsp::lang_assign_var_array_idxvar $tmp_a [::tsp::get_constvar [::tsp::getConstant compUnit [lindex $component 1]]] $tmp_v "Error loading Array Text"]
+					#append code "// Convert array |$tmp_a| to $tmp\n"
+                    append code [::tsp::lang_assign_var_array_idxvar $tmp_a [::tsp::get_constvar [::tsp::getConstant compUnit [lindex $component 1]]] $tmp_v "Error loading Array Text"]
 					append code [::tsp::lang_convert_string_var $tmp $tmp_a]
 				} else {
 				    set sourceText [lindex $sourceComponents 3]
@@ -724,7 +733,7 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
                     }
 				}
 				if {$targetType eq "string"} {
-					#append code "// Append string |$tmp|\n"
+					#append code "// Append string 727 |$tmp|\n"
 					append code [::tsp::lang_append_string $targetPre$targetVarName $tmp]
 				} elseif {$targetType eq "var"} {
 					#append code "// Append var |$tmp|\n"
@@ -732,7 +741,7 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
 				}
 				#append code [::tsp::lang_assign_empty_zero $tmp string]
 				if {$doreturn>0} {
-				    append code "// exiting\n"
+				    #append code "// exiting\n"
 					return $code
 				}
             }
@@ -759,8 +768,11 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
                     }
 				}
 				if {$targetType eq "string"} {
-					#append code "// Append string |$tmp|\n"
-					append code [::tsp::lang_append_string $targetPre$targetVarName $tmp]
+					#append code "// Append string 763 |$tmp|\n"
+					##???append code [::tsp::lang_append_string $targetPre$targetVarName $tmp]
+					### deleted this output 23-Oct 20, since it produced continuosly double output with 
+					### Line 781 string case
+					#append code "// ok;\n"
 				} elseif {$targetType eq "var"} {
 					#append code "// Append var |$tmp|\n"
 					append code [::tsp::lang_assign_var_string $targetVarName $tmp]
@@ -777,6 +789,7 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
             }
         }
         if {$targetType eq "string"} {
+            append code "// Append string 781 |$tmp|\n"
             append code [::tsp::lang_append_string $targetPre$targetVarName $tmp]
         } elseif {$targetType eq "var"} {
             append code [::tsp::lang_append_string $tmp2 $tmp]
diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index e40e358..c22cccb 100755
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -7,7 +7,7 @@
 # PACKAGENAME_tsp_YYYY-MM-DD-hh-mm-ss.tcl (with tsp directives to create package)
 # pkgIndex.tcl
 # PACKAGENAME.puretcl.tcl (Untouched, pure TCL procs)
-# PACKAGENAME.tclorig.tcl (TCL Replacment procs)
+# PACKAGENAME.tclprocs.tcl (TCL Replacment procs)
 # PACKAGENAME.c (sourcecode, final)
 # PACKAGENAME.dll (binary file)
 # 
@@ -29,6 +29,7 @@ namespace eval ::tsp {
     variable PACKAGE_NAME ""
     variable PACKAGE_VERSION "1.0"
     variable PACKAGE_DIR ""
+    variable TSPPACKAGE_SPACE [file normalize [file dirname [info script]]]
     variable TCL_VERSION "TCL_VERSION"
     variable TCL_PROCS ""
     # load tcls for additional sources
@@ -49,9 +50,11 @@ proc ::tsp::hook_proc {level} {
     # we hook the proc construct to get information about package defined procs
     variable _HOOK_LEVEL
     set _HOOK_LEVEL $level
+    #puts "Hooking proc $level"
     if {[info command ::__proc] eq ""} {
         rename ::proc ::__proc
         ::__proc ::proc {procName procargs procbody} {
+            #puts "Hook hit $procName in -[info script]- lv [info level]==$::tsp::_HOOK_LEVEL ?"
             if {([info script] eq "")&&([info level]==$::tsp::_HOOK_LEVEL)} {
                 lappend ::tsp::TCL_PROCS  [list $procName $procargs $procbody]
             }
@@ -150,7 +153,7 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
         } else {
             set ::tsp::COMPILE_DIRECTIVES [::tcc4tcl::write_packagecode $::tsp::TCC_HANDLE $::tsp::PACKAGE_NAME $tsp::PACKAGE_DIR $::tsp::PACKAGE_VERSION $::tsp::TCL_VERSION]
         }
-    }
+    } 
     
     ::tsp::write_pkgAltTcl $::tsp::PACKAGE_NAME
     ::tsp::write_pkgIndex $::tsp::PACKAGE_NAME
@@ -174,8 +177,17 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
     }
     
     ::tsp::compile_package $::tsp::PACKAGE_NAME $compiler
+    # pkginit?
+    if {$::tsp::PACKAGE_INIT_PROC>0} {
+        if {$compiler in "intern memory"} {
+            if {[catch {${::tsp::PACKAGE_NAME}_pkgInit} e]} {
+                puts "error: $e"
+            }
+        }
+    }
     set ::tsp::COMPILE_PACKAGE 0
     set ::tsp::PACKAGE_NAME ""
+        
 }
 
 proc ::tsp::addExternalCompiler {compiler ccOptions exeDir exeFile {compilertype gccwin32}} {
@@ -212,25 +224,29 @@ proc ::tsp::add_dllinclude {fname} {
     lappend ::tsp::EXTERNAL_DLLS $fname
 }
 
-proc ::tsp::test_packageX {packagename {callcmd ""} {shell "./tclkit_8.6.12.exe"}} {
+proc ::tsp::test_packageX {packagename {callcmd ""} {shell "tclkit_8.6.12.exe"}} {
     # ok, now things really get difficult, if the directory structure doesn't work "./tclkit_866_3.upx.exe"
     # this actually only works under windows, you need a tclkit named $shell in the current working dir
-    set result "failed testloading package $packagename"
+    set result "failed testloading package $packagename in [pwd]"
     set callresult ""
     set packagedir [file dir $packagename]
     set packagename [file tail $packagename]
-    puts "Testing package $packagename"
+    puts "Testing package $packagename in [pwd]"
     if {[catch {
         puts "Creating new exec"
-        set fd [open resrc.tcl w]
+        set res_name [file normalize resrc.tcl]
+        set fd [open $res_name w]
         puts $fd "#!/usr/bin/tclsh"
         puts $fd "catch {console show}"
-        puts "appending auto_path with [file dir $tsp::PACKAGE_DIR]"
-        puts $fd "lappend auto_path [file dir $tsp::PACKAGE_DIR]"
+        puts "appending auto_path with [file normalize [file dir $tsp::PACKAGE_DIR]]"
+        puts $fd "lappend auto_path [file normalize [file dir $tsp::PACKAGE_DIR]]"
+        puts "Testing for [file dir $tsp::PACKAGE_DIR] ne $packagedir"
         if {[file dir $tsp::PACKAGE_DIR] ne $packagedir} {
             puts "appending auto_path with $packagedir"
             puts $fd "lappend auto_path $packagedir"
         }
+        puts "Appending $tsp::TSPPACKAGE_SPACE"
+        puts $fd "lappend auto_path $tsp::TSPPACKAGE_SPACE"
         puts "Loading package... $packagename"
         puts $fd "package require $packagename"
         
@@ -247,11 +263,12 @@ proc ::tsp::test_packageX {packagename {callcmd ""} {shell "./tclkit_8.6.12.exe"
     # shell actually hardcoded... todo implement some clever routine to find nearest kit
     # and to run under linux
     if {$::tcl_platform(platform)=="unix"} {
-        puts "Seems to be a native linux, calling tclsh"
+        puts "Seems to be a native linux, calling tclsh $res_name"
         #exec >@stdout tclsh resrc.tcl
         # solution:
-        set runcmd [list exec tclsh resrc.tcl 2>@stderr]
-        
+        set runcmd "exec tclsh \"$res_name\" 2>@stderr"
+        #"
+        puts "running $runcmd"
         if {[catch $runcmd res]} {
           error "Failed to run command $runcmd: $res"
         }
@@ -264,10 +281,15 @@ proc ::tsp::test_packageX {packagename {callcmd ""} {shell "./tclkit_8.6.12.exe"
                 # mark your shells as tclkit-8.6.6.exe to get found 866 8-6-6 all will do
                 # this will search for 8.6.6 shell
                 # or at least any 8.6 shell
-                set flist [glob tclkit*.exe]
+                set flist [glob -nocomplain tclkit*.exe]
+                if {[llength $flist]==0} {
+                    puts "Shell not found in ./ ... searching $::tccenv::tclexedir"
+                    set flist [glob -nocomplain [file join $::tccenv::tclexedir tclkit*.exe]]
+                    puts $flist
+                }
                 set cand ""
                 foreach kit $flist {
-                    set vnum [join [regexp -all -inline "\[0-9\]" $kit]]
+                    set vnum [join [regexp -all -inline "\[0-9\]" [file tail $kit]]]
                     set vstring2 [join [lrange $vnum 0 1] "."]
                     set vstring3 [join [lrange $vnum 0 2] "."]
                     if {$vstring2 eq "8.6"} {
@@ -290,7 +312,7 @@ proc ::tsp::test_packageX {packagename {callcmd ""} {shell "./tclkit_8.6.12.exe"
                 puts "using $shell"
                 
             }
-            exec $shell resrc.tcl &
+            exec $shell $res_name &
         } err]} {
                 puts "Error while preparing package $packagename\n$err"
         }
@@ -381,18 +403,20 @@ proc ::tsp::rewrite_procnamespace {} {
             # pure c implemented... there will be no valid TCL representation
             ##set procdef [list $procname "args" [list puts "Not implemented \"$procname\""]]
             ##lappend ::tsp::PACKAGE_PROCS $procname $procdef
-            set cdef [dict get $state(procdefs) $procname]
-            lassign $cdef cprocname rtype cprocargs
-            set procargs ""
-            set procargsfull ""
-            foreach {ctype vname} $cprocargs {
-                lappend procargs $ctype
-                if {$vname!= "interp"} {
-                    lappend procargsfull $vname
+            catch {
+                set cdef [dict get $state(procdefs) $procname]
+                lassign $cdef cprocname rtype cprocargs
+                set procargs ""
+                set procargsfull ""
+                foreach {ctype vname} $cprocargs {
+                    lappend procargs $ctype
+                    if {$vname!= "interp"} {
+                        lappend procargsfull $vname
+                    }
                 }
+                set procdef [list $procname "$procargsfull" [list puts "Not implemented \"$procname\""]]
+                lappend ::tsp::PACKAGE_PROCS $procname $procdef
             }
-            set procdef [list $procname "$procargsfull" [list puts "Not implemented \"$procname\""]]
-            lappend ::tsp::PACKAGE_PROCS $procname $procdef
             #lappend ::tsp::COMPILED_PROCS $procname [list $rtype $procargs $cprocname]
         }
     }
@@ -411,31 +435,47 @@ proc ::tsp::rewrite_procnamespace {} {
     set state(procs) $nsprocs
 }
 
-proc ::tsp::write_pkgIndex {packagename} {
-    # write a pkindex.tcl file to load package
-    if {$tsp::PACKAGE_DIR eq ""} {
-        set filename [file join $tsp::PACKAGE_DIR "$packagename.pkgIndex.tcl"]
-    } else {
-        set filename [file join $tsp::PACKAGE_DIR "pkgIndex.tcl"]
-    }
-    set fd [open $filename w]
-    puts $fd "# Package Index for $packagename generated by TSP//TCCIDE Version $::_version"
-    puts $fd "# Compiled Procs "
-    puts $fd ""
+proc ::tsp::getProcIndex {packagename} {
+    #
+    set helpindex ""
+    lappend helpindex "# Help Index:"
+    lappend helpindex "# Generated at [set t [clock format [clock seconds] -format "%Y-%m-%d_%H-%M-%S"]]"
+    lappend helpindex "# Package Index/Loader for $packagename generated by TSP//TCCIDE Version $::_version"
+    lappend helpindex ""
+    lappend helpindex "# Compiled Procs "
+    lappend helpindex ""
     set cpr {}
     catch {set cpr $::tsp::PACKAGE_PROCS}
     foreach {procname procdef} $cpr {
         lassign $procdef cproc cvars cbody
-        puts $fd "# ${::tsp::PACKAGE_NAMESPACE}::$cproc $cvars"
+        lappend helpindex "# ${::tsp::PACKAGE_NAMESPACE}::$cproc $cvars"
     }
-    puts $fd "\n# TCL Procs "
-    puts $fd ""
+    lappend helpindex ""
+    lappend helpindex "# TCL Procs "
+    lappend helpindex ""
     set tclpr {}
     catch {set tclpr $::tsp::TCL_PROCS}
     foreach tcldef $tclpr {
         lassign $tcldef cproc cvars cbody
-        puts $fd [string map {\n "."} "# $cproc $cvars"]
+        lappend helpindex [string map {\n "."} "# $cproc $cvars"]
+    }
+    return [join $helpindex \n]
+}
+
+proc ::tsp::write_pkgIndex {packagename} {
+    # write a pkgindex.tcl file to load package
+    if {$tsp::PACKAGE_DIR eq ""} {
+        set filename [file join $tsp::PACKAGE_DIR "$packagename.pkgIndex.tcl"]
+        set loadername [file join $tsp::PACKAGE_DIR "$packagename.${packagename}.loader.tcl"]
+    } else {
+        set filename [file join $tsp::PACKAGE_DIR "pkgIndex.tcl"]
+        set loadername [file join $tsp::PACKAGE_DIR "${packagename}.loader.tcl"]
     }
+    
+    set fd [open $loadername w]
+
+    puts $fd [::tsp::getProcIndex $packagename]
+    
     set handle $::tsp::TCC_HANDLE
     set loadextlibs "proc ${packagename}_loadextdlls {dir} {\ncatch {\n"
     append loadextlibs {
@@ -468,17 +508,19 @@ proc ::tsp::write_pkgIndex {packagename} {
     }
     
     set pkgloadlib  "proc ${packagename}_loadlib {dir packagename} {\n"
-    if {$loadextlibs ne ""} {
+    if {($loadextlibs ne "")} {
         append pkgloadlib "     ${packagename}_loadextdlls \$dir\n"
+    }
+    if {($loadextlibs ne "")||($::tsp::LOAD_DLLS ne "")} {
         append pkgloadlib "     ${packagename}_loadext \$dir\n"
     }
-    if {$cpr ne ""} {
+    if {$::tsp::PACKAGE_PROCS ne ""} {
         append pkgloadlib "     if {\[catch {load \[file join \$dir \$packagename\[info sharedlibextension\]\]} err\]} {\n"
         append pkgloadlib "         source  \[file join \$dir \${packagename}.tclprocs.tcl\]\n"
         append pkgloadlib "     }\n"
     }
     
-    if {$tclpr ne ""} {
+    if {$::tsp::TCL_PROCS ne ""} {
         # load puretcl proc also
         append pkgloadlib "     source  \[file join \$dir \${packagename}.puretcl.tcl\]\n" 
         if {$::tsp::PACKAGE_INIT_PROC>0} {
@@ -501,19 +543,39 @@ proc ::tsp::write_pkgIndex {packagename} {
     }
     append pkgloadext "}\n"
     
-    
-    set pkgrun "package ifneeded $packagename $::tsp::PACKAGE_VERSION \[list ${packagename}_loadlib \$dir {$packagename}\]\n"
+    set pkgrun "#run loader here\n${packagename}_loadlib \[file dir \[info script\]\] {$packagename}\n"
 
     puts $fd $loadextlibs
     puts $fd $pkgloadlib
     puts $fd $pkgloadext
     puts $fd $pkgrun
     close $fd
+    
+    set fd [open $filename w]
+    
+    set pkgrun "package ifneeded $packagename $::tsp::PACKAGE_VERSION \[list source \[file join \$dir [file tail $loadername]\]\]"
+    puts $fd $pkgrun
+    close $fd
 }
 
 proc ::tsp::write_pkgAltTcl {packagename} {
     # write an tcl file to keep all procs as alternate to compiled procs (can't load)
     # and those procs, that we didn't compile
+    
+    # add a little help function
+    if {$::tsp::PACKAGE_NAMESPACE eq ""} {
+        set help_proc ${packagename}_help
+    } else {
+        set help_proc ${::tsp::PACKAGE_NAMESPACE}::help
+    }
+    
+    set help_body " puts {\n"
+    append help_body [::tsp::getProcIndex $packagename]
+    append help_body "\n}\n"
+    set help_procdef [list $help_proc "" $help_body]
+    
+    lappend ::tsp::TCL_PROCS $help_procdef
+    
     set filename [file join $tsp::PACKAGE_DIR "$packagename.tclprocs.tcl"]
     set fd [open $filename w]
     puts $fd "#  TSP Pure TCL procs for loadlib failure management"
diff --git a/tsp-types.tcl b/tsp-types.tcl
index 0feb50a..65d383c 100755
--- a/tsp-types.tcl
+++ b/tsp-types.tcl
@@ -492,7 +492,8 @@ proc ::tsp::reset_tmpvarsUsed {compUnitDict} {
 
 proc ::tsp::get_tmpvar {compUnitDict type {varName ""}} {
     upvar $compUnitDict compUnit
-
+    #set callerlevel [expr [info level]-1]
+    #puts "tempvar $type requested from $callerlevel: [info level $callerlevel]"
     if {[lsearch $::tsp::VAR_TYPES $type] < 0 || $type eq "array"} {
         error "::tsp::get_tmpvar - invalid var type $type\n[::tsp::currentLine compUnit]\n[::tsp::error_stacktrace]"
     }

From d14300a284a1c4ce1ebbca72044c826638947434 Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Sat, 21 Dec 2024 09:03:30 +0100
Subject: [PATCH 35/39] Some bugfixes regarding arrays and self referent
 strings

---
 tcc4tcl_helper.tcl    |  48 ++++++++++++++--
 tsp-generate-set.tcl  |  75 ++++++++++++++++++-------
 tsp-packagehelper.tcl | 126 +++++++++++++++++++++++++++---------------
 tsp-types.tcl         |  19 ++++---
 4 files changed, 192 insertions(+), 76 deletions(-)

diff --git a/tcc4tcl_helper.tcl b/tcc4tcl_helper.tcl
index f8759f5..c6f81bb 100644
--- a/tcc4tcl_helper.tcl
+++ b/tcc4tcl_helper.tcl
@@ -297,7 +297,7 @@ proc ::tcc4tcl::prepare_compilerdirectives {filepath handle} {
     
     set ccoptionstccwin32 "-m32 -D_WIN32 "
     set ccoptionsgccwin32 "-s -m32 -D_WIN32 -static-libgcc "
-    set ccoptionstcclin64 {-Wl,-rpath='.'}
+    set ccoptionstcclin64 {-Wl,-rpath=.}
     set ccoptionsgcclin64 {-s -fPIC -D_GNU_SOURCE -Wl,-rpath=. }
     
     set ccoptionstccuser ""
@@ -375,6 +375,42 @@ proc ::tcc4tcl::prepare_compilerdirectives {filepath handle} {
     return $ccdirectives
 }
 
+proc lstride {L n} {
+   set t [list]; set res [list]
+   foreach i $L {
+      lappend t $i
+      if {[llength $t]==$n} {
+         lappend res $t
+         set t [list]
+      }
+   }
+   if [llength $t] {lappend res $t} ;# maybe keep the rest
+   set res
+}
+
+proc ::tcc4tcl::dlexport_procdefs {procdefs proclist} {
+    #
+    ### experimental insert###
+    #
+    ##########################
+    #
+    set exportcode ""
+    foreach {procname cname_obj} $procdefs {
+        # [list $tclname $rtype $adefs]
+        lassign $cname_obj cname rtype adefs
+        if {[string range $procname 0 1]!="__"} {;#rmoeve special procs
+            #
+            set adefs [lstride $adefs 2]
+            set adefs [join $adefs ,]
+            set dlcode "DLLEXPORT $rtype $cname ($adefs);\n"
+            puts "$procname -> obj $cname_obj cname $cname rtype $rtype adefs $adefs"
+            puts $dlcode
+            append exportcode $dlcode
+        }
+    }
+    return $exportcode
+}
+
 proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packageversion 1.0} {tclversion TCL_VERSION}} {
     proc relTo {targetfile currentpath } {
         # Get relative path to target file from current path
@@ -422,7 +458,7 @@ proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packagevers
             default {\n}
         }
     }
-
+    
     set DLEXPORTMAKRO $::tccenv::DLEXPORTMAKRO
     upvar #0 $handle state
     set oldtype "package"
@@ -432,14 +468,18 @@ proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packagevers
         set state(type) "package"
     }
     
+    set compiletime [clock format [clock seconds]]
+
     #modify code with dlexportmakro
     set oldcode $state(code)
     set newcode $DLEXPORTMAKRO
     append newcode $oldcode
+    #append newcode [::tcc4tcl::dlexport_procdefs $state(procdefs) ""]
     set state(code) $newcode
     
     puts "Writing Package $packagename --> $filepath"
     set mycode [$handle code]
+    
     # beautify code
     set mycode [::tcc4tcl::reformat [string map [list [eol] \n] $mycode] 4]
     set $state(type) $oldtype
@@ -447,13 +487,13 @@ proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packagevers
     set filename [file join $filepath "$packagename.c"]
     set ccdirectives [::tcc4tcl::prepare_compilerdirectives $filename $::tsp::TCC_HANDLE]
     set fp [open $filename w]
-    puts $fp "/***************** Automatically Created with TCC4TCL Helper and maybe TSP **********************************/"
+    puts $fp "/***************** $compiletime Automatically Created with TCC4TCL Helper and maybe TSP **********************************/"
     puts $fp "/* Compiler directives are raw estimates, please adapt to given pathstructure */\n"
     foreach {compiler ccdirective} $ccdirectives {
         puts $fp "/* for $compiler use */"
         puts $fp "/* $ccdirective */\n"
     }
-    puts $fp "/***************** Automatically Created with TCC4TCL Helper and maybe TSP **********************************/"
+    puts $fp "/***************** $compiletime Automatically Created with TCC4TCL Helper and maybe TSP **********************************/"
     puts $fp $mycode
     close $fp
     return $ccdirectives
diff --git a/tsp-generate-set.tcl b/tsp-generate-set.tcl
index e01392b..9054de4 100755
--- a/tsp-generate-set.tcl
+++ b/tsp-generate-set.tcl
@@ -142,6 +142,7 @@ proc ::tsp::produce_set {compUnitDict tree targetComponents sourceComponents} {
             # variable parsed as an array, but some other type
             set errors 1
             ::tsp::addError compUnit "set arg 1 \"$targetVarName\" previously defined as type: \"$targetType\", now referenced as array"
+            #puts "set arg 1 \"$targetVarName\" previously defined as type: \"$targetType\", now referenced as array"
         }
 
         # is index a string or variable?
@@ -637,11 +638,29 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
     # puts "gen_assign_var_string_interpolated_string- ::tsp::setDirty compUnit $targetVarName"
     ::tsp::setDirty compUnit $targetVarName 
     
-    set targetPre [::tsp::var_prefix $targetVarName]
+    set recursiveSet ""
+    set oldTarget $targetVarName
+    
+    foreach component $sourceComponents {
+        # preanalyse, if recursive set occurs
+        set compType [lindex $component 0]
+        set sourceVarName [lindex $component 1]
+        if {$sourceVarName==$targetVarName} {
+            if {$compType=="scalar"} {
+                append code "// DEBUG: recursive set $sourceVarName \n"
+                set recursiveSet [::tsp::get_tmpvar compUnit string]
+                set targetVarName $recursiveSet
+                append code [::tsp::lang_assign_empty_zero $recursiveSet string]
+            } else {
+                ::tsp::addError compUnit "recursive assignment to \"$targetVarName\""
+                return ERROR
+            }
+        }            
+    }
 
+    set targetPre [::tsp::var_prefix $targetVarName]
     append result "\n/***** ::tsp::gen_assign_var_string_interpolated_string */\n"
     
-    
     set tmp [::tsp::get_tmpvar compUnit string]
     set tmp2 ""
     set arrVar ""
@@ -668,6 +687,10 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
             scalar {
                 # assignment from native variable or var, possible type coersion
                 set sourceVarName [lindex $component 1]
+                if {$sourceVarName==$targetVarName} {
+                    # create another tempvar
+                    append code "// DEBUG: sourceVarName=targetVarName=$targetVarName \n"
+                }
                 set sourceType [::tsp::getVarType compUnit $sourceVarName]
                 if {$sourceType eq "undefined"} {
                     ::tsp::addError compUnit "set command arg 2 interpolated string variable not defined: \"$sourceVarName\""
@@ -692,17 +715,16 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
                 append code [::tsp::gen_assign_scalar_scalar compUnit $tmp string $sourceRhsVar $sourceType ]
             }
             text_array_idxvar - array_idxvar {
-                puts "//Parsing Array $compType in $component of $sourceComponents\n"
                  append code "//Parsing Array $compType in $component of $sourceComponents\n"
                  #::tsp::addWarning compUnit "$compType not implemented $component $sourceComponents"
-                 #append code "// Parsing $component in $sourceComponents\n"
+                 #append code "//Parsing $component in $sourceComponents\n"
 				set tmp_s [::tsp::get_tmpvar compUnit string]
 				set doreturn 0
 
                 # assignment from native variable or var, possible type coersion
                 set sourceVarName [lindex $component 2]
-                #append code "// assignment  |$sourceVarName| to $tmp_s\n"
                 set sourceType [::tsp::getVarType compUnit $sourceVarName]
+                #append code "// assignment  |$sourceVarName|$sourceType| to $tmp_s\n"
                 if {$sourceType eq "undefined"} {
                     ::tsp::addError compUnit "set command arg 2 interpolated string variable not defined: \"$sourceVarName\""
                     return [list ""]
@@ -716,6 +738,7 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
 					append code [::tsp::lang_assign_var_string $tmp_v $tmp_s]
 					#append code "// Convert array |$tmp_a| to $tmp\n"
                     append code [::tsp::lang_assign_var_array_idxvar $tmp_a [::tsp::get_constvar [::tsp::getConstant compUnit [lindex $component 1]]] $tmp_v "Error loading Array Text"]
+                    append code "//DEBUG1: lang_convert_string_var after array \n"
 					append code [::tsp::lang_convert_string_var $tmp $tmp_a]
 				} else {
 				    set sourceText [lindex $sourceComponents 3]
@@ -733,11 +756,11 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
                     }
 				}
 				if {$targetType eq "string"} {
-					#append code "// Append string 727 |$tmp|\n"
-					append code [::tsp::lang_append_string $targetPre$targetVarName $tmp]
+					append code "// Append string 727 dropped |$tmp|\n"
+					#append code [::tsp::lang_append_string $targetPre$targetVarName $tmp]
 				} elseif {$targetType eq "var"} {
-					#append code "// Append var |$tmp|\n"
-					append code [::tsp::lang_assign_var_string $targetVarName $tmp]
+					append code "// Append var 740 dropped |$tmp|\n"
+					#append code [::tsp::lang_assign_var_string $targetVarName $tmp]
 				}
 				#append code [::tsp::lang_assign_empty_zero $tmp string]
 				if {$doreturn>0} {
@@ -746,8 +769,15 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
 				}
             }
             text_array_idxtext - array_idxtext {
-                 append code "//Parsing Array $compType in $component of $sourceComponents\n"
+                append code "//Parsing Array $compType in $component of $sourceComponents\n"
 				set tmp_s [::tsp::get_tmpvar compUnit string]
+                set sourceVarName [lindex $component 1]
+                set sourceType [::tsp::getVarType compUnit $sourceVarName]
+                #append code "// assignment  |$sourceVarName|$sourceType| to $tmp_s\n"
+                if {($sourceVarName ne "") && ($sourceType ne "array")} {
+                    ::tsp::addError compUnit "set command argument not defined as array but as $sourceType: \"$sourceVarName\""
+                    return [list ""]
+                }
 				set doreturn 0
 				if {($compType=="array_idxtext")} {
 					#::tsp::addWarning compUnit "set arg 2 interpolated string cannot contain $compType as $component in $sourceComponents, only commands, text, backslash, or scalar variables"
@@ -767,16 +797,16 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
                         set doreturn 1
                     }
 				}
-				if {$targetType eq "string"} {
-					#append code "// Append string 763 |$tmp|\n"
-					##???append code [::tsp::lang_append_string $targetPre$targetVarName $tmp]
-					### deleted this output 23-Oct 20, since it produced continuosly double output with 
-					### Line 781 string case
-					#append code "// ok;\n"
-				} elseif {$targetType eq "var"} {
-					#append code "// Append var |$tmp|\n"
-					append code [::tsp::lang_assign_var_string $targetVarName $tmp]
-				}
+                if {$targetType eq "string"} {
+                    #append code "// Append string 763 |$tmp|\n"
+                    ##???append code [::tsp::lang_append_string $targetPre$targetVarName $tmp]
+                    ### deleted this output 23-Oct 20, since it produced continuosly double output with 
+                    ### Line 781 string case
+                    #append code "// ok;\n"
+                } elseif {$targetType eq "var"} {
+                    append code "// Append var 778 |$tmp|\n"
+                    append code [::tsp::lang_assign_var_string $targetVarName $tmp]
+                }
 				#append code [::tsp::lang_assign_empty_zero $tmp string]
 				if {$doreturn>0} {
 				    append code "// exiting\n"
@@ -795,6 +825,11 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
             append code [::tsp::lang_append_string $tmp2 $tmp]
         }
     }
+    if {$recursiveSet!=""} {
+        append code "// DEBUG: had recursive set\n"
+        append code [::tsp::lang_convert_string_string [::tsp::var_prefix $oldTarget]$oldTarget $targetPre$targetVarName]
+        set targetVarName $oldTarget
+    }
     if {$targetType eq "var"} {
         append code [::tsp::gen_assign_scalar_scalar compUnit $targetVarName var $tmp2 string]
     }
diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index c22cccb..d56cfda 100755
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -55,16 +55,27 @@ proc ::tsp::hook_proc {level} {
         rename ::proc ::__proc
         ::__proc ::proc {procName procargs procbody} {
             #puts "Hook hit $procName in -[info script]- lv [info level]==$::tsp::_HOOK_LEVEL ?"
-            if {([info script] eq "")&&([info level]==$::tsp::_HOOK_LEVEL)} {
-                lappend ::tsp::TCL_PROCS  [list $procName $procargs $procbody]
+            set nsprocname $procName
+            if {(([info script] eq "")||([info script] eq $::tsp::ACTSOURCE))&&([info level]==$::tsp::_HOOK_LEVEL)} {
+                #puts "lappend ::tsp::TCL_PROCS  [list $procName $procargs $procbody]"
+                if {$::tsp::PACKAGE_NAMESPACE ne ""} {
+                    set nsprocname ::${::tsp::PACKAGE_NAMESPACE}::$procName
+                    puts "Namespace rewriting $procName to $nsprocname"
+                    # check if namespace exists or create it
+                    if {[namespace exists ::${::tsp::PACKAGE_NAMESPACE}]==0} {
+                        namespace eval ::${::tsp::PACKAGE_NAMESPACE} {}
+                    }
+                }
+                lappend ::tsp::TCL_PROCS  [list $nsprocname $procargs $procbody]
             }
-            if {[catch {uplevel 0 ::__proc [list $procName $procargs $procbody]} err]} {
+            if {[catch {uplevel 0 ::__proc [list $nsprocname $procargs $procbody]} err]} {
                 rename ::proc ""
                 rename ::__proc ::proc
                 return -code error "Error in proc $err"
             }
         }
     }
+
 }
 
 proc ::tsp::unhook_proc {} {
@@ -96,7 +107,7 @@ proc ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0}
     catch { unset ::tsp::TCC_HANDLE}
     set ::tsp::TCC_HANDLE [tcc4tcl::new]
 
-    set ::tsp::PACKAGE_PROCS ""
+    set ::tsp::NAMESPACE_VARS ""
     set ::tsp::PACKAGE_INIT_PROC 0
     set ::tsp::TCL_PROCS ""
     set ::tsp::PACKAGE_HEADER \
@@ -123,7 +134,9 @@ proc ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0}
     
     ::tsp::hook_proc [info level]
 }
-
+proc ::tsp::package_export {exportprocnames} {
+    #
+}
 proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
     ::tsp::unhook_proc
 
@@ -136,9 +149,9 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
         return
     }
 
-    set tsp::PACKAGE_DIR $packagedir
-    if {![file isdir $tsp::PACKAGE_DIR]} {
-        file mkdir $tsp::PACKAGE_DIR
+    set ::tsp::PACKAGE_DIR $packagedir
+    if {![file isdir $::tsp::PACKAGE_DIR]} {
+        file mkdir $::tsp::PACKAGE_DIR
     }
     
     ::tsp::rewrite_procnamespace
@@ -151,10 +164,25 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
             set ::tsp::COMPILE_DIRECTIVES ""
             puts "failed crafting compiledirectives... use package require tcc4tcc-helper"
         } else {
-            set ::tsp::COMPILE_DIRECTIVES [::tcc4tcl::write_packagecode $::tsp::TCC_HANDLE $::tsp::PACKAGE_NAME $tsp::PACKAGE_DIR $::tsp::PACKAGE_VERSION $::tsp::TCL_VERSION]
+            set ::tsp::COMPILE_DIRECTIVES [::tcc4tcl::write_packagecode $::tsp::TCC_HANDLE $::tsp::PACKAGE_NAME $::tsp::PACKAGE_DIR $::tsp::PACKAGE_VERSION $::tsp::TCL_VERSION]
         }
     } 
     
+    # add a little help function
+    if {$::tsp::PACKAGE_NAMESPACE eq ""} {
+        set help_proc ::${::tsp::PACKAGE_NAME}_help
+    } else {
+        set help_proc ::${::tsp::PACKAGE_NAMESPACE}::help
+    }
+    # add help-index
+    set help_body " puts {\n"
+    append help_body [::tsp::getProcIndex $::tsp::PACKAGE_NAME]
+    append help_body "\n}\n"
+    set help_procdef [list $help_proc "" $help_body]
+    set cmd "::$help_proc {} $help_body"
+    ::proc ::$help_proc {} $help_body
+    lappend ::tsp::TCL_PROCS $help_procdef
+    
     ::tsp::write_pkgAltTcl $::tsp::PACKAGE_NAME
     ::tsp::write_pkgIndex $::tsp::PACKAGE_NAME
     
@@ -163,10 +191,10 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
     if {($::tsp::ACTSOURCE ne "")&&[file exist $::tsp::ACTSOURCE]} {
         set t [clock format [clock seconds] -format "%Y-%m-%d_%H-%M-%S"]
         set srcname "${::tsp::PACKAGE_NAME}_tsp_${t}.tcl"
-        set srcname [file join $tsp::PACKAGE_DIR $srcname]
+        set srcname [file join $::tsp::PACKAGE_DIR $srcname]
         set vdiff 1
         catch {
-            set lastsrcname [file join $tsp::PACKAGE_DIR "${::tsp::PACKAGE_NAME}_tsp_*.tcl"]
+            set lastsrcname [file join $::tsp::PACKAGE_DIR "${::tsp::PACKAGE_NAME}_tsp_*.tcl"]
             set lastsrcname [lindex [lsort -decreasing [glob $lastsrcname]] 0]
             set vdiff [version:filediff $::tsp::ACTSOURCE $lastsrcname]
         }
@@ -177,6 +205,7 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
     }
     
     ::tsp::compile_package $::tsp::PACKAGE_NAME $compiler
+
     # pkginit?
     if {$::tsp::PACKAGE_INIT_PROC>0} {
         if {$compiler in "intern memory"} {
@@ -238,15 +267,15 @@ proc ::tsp::test_packageX {packagename {callcmd ""} {shell "tclkit_8.6.12.exe"}}
         set fd [open $res_name w]
         puts $fd "#!/usr/bin/tclsh"
         puts $fd "catch {console show}"
-        puts "appending auto_path with [file normalize [file dir $tsp::PACKAGE_DIR]]"
-        puts $fd "lappend auto_path [file normalize [file dir $tsp::PACKAGE_DIR]]"
-        puts "Testing for [file dir $tsp::PACKAGE_DIR] ne $packagedir"
-        if {[file dir $tsp::PACKAGE_DIR] ne $packagedir} {
+        puts "appending auto_path with [file normalize [file dir $::tsp::PACKAGE_DIR]]"
+        puts $fd "lappend auto_path [file normalize [file dir $::tsp::PACKAGE_DIR]]"
+        puts "Testing for [file dir $::tsp::PACKAGE_DIR] ne $packagedir"
+        if {[file dir $::tsp::PACKAGE_DIR] ne $packagedir} {
             puts "appending auto_path with $packagedir"
             puts $fd "lappend auto_path $packagedir"
         }
-        puts "Appending $tsp::TSPPACKAGE_SPACE"
-        puts $fd "lappend auto_path $tsp::TSPPACKAGE_SPACE"
+        puts "Appending $::tsp::TSPPACKAGE_SPACE"
+        puts $fd "lappend auto_path $::tsp::TSPPACKAGE_SPACE"
         puts "Loading package... $packagename"
         puts $fd "package require $packagename"
         
@@ -329,8 +358,8 @@ proc ::tsp::test_package {packagename {callcmd ""}} {
     if {[catch {
         puts "Creating new interp"
         set ip [interp create]
-        puts "appending auto_path with [file dir $tsp::PACKAGE_DIR]"
-        $ip eval lappend auto_path [file dir $tsp::PACKAGE_DIR]
+        puts "appending auto_path with [file dir $::tsp::PACKAGE_DIR]"
+        $ip eval lappend auto_path [file dir $::tsp::PACKAGE_DIR]
         puts "Loading package... $packagename"
         set result [$ip eval package require $packagename]
         if {$callcmd ne ""} {
@@ -362,9 +391,9 @@ proc ::tsp::test_altpackage {packagename {callcmd ""}} {
         puts "Creating new interp"
         set ip [interp create]
         puts "Loading TCL package... $packagename.tclprocs.tcl"
-        set result [$ip eval source [file join $tsp::PACKAGE_DIR "${packagename}.tclprocs.tcl"]]
+        set result [$ip eval source [file join $::tsp::PACKAGE_DIR "${packagename}.tclprocs.tcl"]]
         puts "Loading TCL package... $packagename.puretcl.tcl"
-        set result [$ip eval source [file join $tsp::PACKAGE_DIR "${packagename}.puretcl.tcl"]]
+        set result [$ip eval source [file join $::tsp::PACKAGE_DIR "${packagename}.puretcl.tcl"]]
         if {$callcmd ne ""} {
             puts "Calling $callcmd"
             catch {
@@ -447,8 +476,10 @@ proc ::tsp::getProcIndex {packagename} {
     set cpr {}
     catch {set cpr $::tsp::PACKAGE_PROCS}
     foreach {procname procdef} $cpr {
-        lassign $procdef cproc cvars cbody
-        lappend helpindex "# ${::tsp::PACKAGE_NAMESPACE}::$cproc $cvars"
+        if {[string range $procname 0 1]!="__"} {
+            lassign $procdef cproc cvars cbody
+            lappend helpindex "# ${::tsp::PACKAGE_NAMESPACE}::$cproc $cvars"
+        }
     }
     lappend helpindex ""
     lappend helpindex "# TCL Procs "
@@ -464,12 +495,12 @@ proc ::tsp::getProcIndex {packagename} {
 
 proc ::tsp::write_pkgIndex {packagename} {
     # write a pkgindex.tcl file to load package
-    if {$tsp::PACKAGE_DIR eq ""} {
-        set filename [file join $tsp::PACKAGE_DIR "$packagename.pkgIndex.tcl"]
-        set loadername [file join $tsp::PACKAGE_DIR "$packagename.${packagename}.loader.tcl"]
+    if {$::tsp::PACKAGE_DIR eq ""} {
+        set filename [file join $::tsp::PACKAGE_DIR "$packagename.pkgIndex.tcl"]
+        set loadername [file join $::tsp::PACKAGE_DIR "$packagename.${packagename}.loader.tcl"]
     } else {
-        set filename [file join $tsp::PACKAGE_DIR "pkgIndex.tcl"]
-        set loadername [file join $tsp::PACKAGE_DIR "${packagename}.loader.tcl"]
+        set filename [file join $::tsp::PACKAGE_DIR "pkgIndex.tcl"]
+        set loadername [file join $::tsp::PACKAGE_DIR "${packagename}.loader.tcl"]
     }
     
     set fd [open $loadername w]
@@ -481,7 +512,12 @@ proc ::tsp::write_pkgIndex {packagename} {
     append loadextlibs {
         switch -- $::tcl_platform(platform) {
             windows {set appdir [file dir [info nameofexecutable]]}
-            unix {set appdir [file dir [info script]]}
+            unix {
+                set appdir [file dir [info script]]
+                if {$appdir==$dir} {
+                    set appdir [pwd]
+                }
+            }
         }
     }
     append loadextlibs "\n"
@@ -492,7 +528,7 @@ proc ::tsp::write_pkgIndex {packagename} {
         lappend libs {*}$::tsp::EXTERNAL_DLLS
     }
     foreach incpath $libs {
-        if {![file exists [file join $tsp::PACKAGE_DIR $incpath[info sharedlibextension]]]} {
+        if {![file exists [file join $::tsp::PACKAGE_DIR $incpath[info sharedlibextension]]]} {
             set incpath lib$incpath
         }
         append loadextlibs "\nset incdll \[file join \$dir $incpath\[info sharedlibextension\]\]\n"
@@ -564,19 +600,21 @@ proc ::tsp::write_pkgAltTcl {packagename} {
     
     # add a little help function
     if {$::tsp::PACKAGE_NAMESPACE eq ""} {
-        set help_proc ${packagename}_help
+        set help_proc ::${packagename}_help
     } else {
-        set help_proc ${::tsp::PACKAGE_NAMESPACE}::help
+        set help_proc ::${::tsp::PACKAGE_NAMESPACE}::help
     }
     
-    set help_body " puts {\n"
+    set help_body " puts {...\n"
     append help_body [::tsp::getProcIndex $packagename]
     append help_body "\n}\n"
     set help_procdef [list $help_proc "" $help_body]
     
-    lappend ::tsp::TCL_PROCS $help_procdef
+    if {[lsearch -index 0 $::tsp::TCL_PROCS $help_proc]==-1} {
+        lappend ::tsp::TCL_PROCS $help_procdef
+    }
     
-    set filename [file join $tsp::PACKAGE_DIR "$packagename.tclprocs.tcl"]
+    set filename [file join $::tsp::PACKAGE_DIR "$packagename.tclprocs.tcl"]
     set fd [open $filename w]
     puts $fd "#  TSP Pure TCL procs for loadlib failure management"
     puts $fd "#   package $packagename"
@@ -603,7 +641,7 @@ proc ::tsp::write_pkgAltTcl {packagename} {
     }
     close $fd
     
-    set filename [file join $tsp::PACKAGE_DIR "${packagename}.puretcl.tcl"]
+    set filename [file join $::tsp::PACKAGE_DIR "${packagename}.puretcl.tcl"]
     set fd [open $filename w]
     puts $fd "#  TSP Pure TCL procs for loadlib complemenary procs"
     puts $fd "#   package $packagename"
@@ -620,7 +658,7 @@ proc ::tsp::write_pkgAltTcl {packagename} {
         puts $fd "}"
     }
 
-    foreach procdef $tsp::TCL_PROCS {
+    foreach procdef $::tsp::TCL_PROCS {
         lassign $procdef procname procargs procbody
         if {$procname eq "${packagename}_pkgInit"} {
             set ::tsp::PACKAGE_INIT_PROC 1
@@ -678,20 +716,20 @@ proc ::tsp::compile_package {packagename {compiler tccwin32}} {
         return 1
     }
 
-    if {$tsp::COMPILE_DIRECTIVES eq ""} {
+    if {$::tsp::COMPILE_DIRECTIVES eq ""} {
         puts "ERROR: No compiler directives found"
         return -1
     }
-    if {$tsp::PACKAGE_DIR eq ""} {
+    if {$::tsp::PACKAGE_DIR eq ""} {
         puts "No packagedir given, searching in $packagename/$packagename.c"
-        set filename [file join $tsp::PACKAGE_DIR "$packagename.c"]
+        set filename [file join $::tsp::PACKAGE_DIR "$packagename.c"]
         if {![file exists $filename]} {
-            set tsp::PACKAGE_DIR $packagename
+            set ::tsp::PACKAGE_DIR $packagename
         }
     }
 
-    set filename [file join $tsp::PACKAGE_DIR "$packagename.c"]
-    set dllname [file join $tsp::PACKAGE_DIR "$packagename.dll"]
+    set filename [file join $::tsp::PACKAGE_DIR "$packagename.c"]
+    set dllname [file join $::tsp::PACKAGE_DIR "$packagename.dll"]
     if {![file exists $filename]} {
         puts "ERROR: $filename source not found"
         return -1
@@ -702,7 +740,7 @@ proc ::tsp::compile_package {packagename {compiler tccwin32}} {
         cd $::tccenv::tccexecutabledir
     }
     
-    set cdirect [dict get $tsp::COMPILE_DIRECTIVES $compiler]
+    set cdirect [dict get $::tsp::COMPILE_DIRECTIVES $compiler]
     
     puts "Compiling external $cdirect"
     set  ::errorCode ""
diff --git a/tsp-types.tcl b/tsp-types.tcl
index 65d383c..bcb5b74 100755
--- a/tsp-types.tcl
+++ b/tsp-types.tcl
@@ -174,9 +174,9 @@ proc ::tsp::parse_procDefs {compUnitDict def} {
     set validReturnTypes $::tsp::RETURN_TYPES
     set validArgTypes $::tsp::VAR_TYPES
     
-    # patch for native proc withou pushcallframe/popcallframe
+    # patch for native proc without pushcallframe/popcallframe
     dict set compUnit isNative 1
-    set unsupportedTypes "array"
+    set unsupportedTypes [list "array"]
     
     set len [llength $def]
     if {$len < 2} {
@@ -189,12 +189,14 @@ proc ::tsp::parse_procDefs {compUnitDict def} {
     }
     set found [lsearch $validReturnTypes $type]
     if {$found < 0} {
-        ::tsp::addError compUnit "::tsp::procdef: invalid return type: $type"
+        ::tsp::addError compUnit "::tsp::procdef: invalid return type: $type $def"
+        dict set compUnit returns $type
         return
     }
     set unsupported [lsearch $unsupportedTypes $type]
     if {$unsupported>-1} {
-        ::tsp::addWarning compUnit "::tsp::procdef: not a native type $type"
+        ::tsp::addError compUnit "::tsp::procdef: invalid return type: $type $def"
+        dict set compUnit returns $type
         dict set compUnit isNative 0
         return
     }
@@ -246,9 +248,9 @@ proc ::tsp::parse_procDefs {compUnitDict def} {
             set type [lindex $defArgs $i]
             set unsupported [lsearch $unsupportedTypes $type]
             if {$unsupported>-1} {
-                ::tsp::addWarning compUnit "::tsp::procdef: not a native type $type"
+                ::tsp::addError compUnit "::tsp::procdef: invalid argument type $type $def"
                 dict set compUnit isNative 0
-                return
+                #return
             }
             set found [lsearch $validArgTypes $type]
             if {$found < 0} {
@@ -293,10 +295,11 @@ proc ::tsp::parse_varDefs {compUnitDict def} {
         return
     }
     set unsupported [lsearch "array" $type]
+    #set unsupported -1
     if {$unsupported>-1} {
-        ::tsp::addWarning compUnit "::tsp::procdef: not a native type $type"
+        #::tsp::addWarning compUnit "::tsp::procdef: not a native type $type $def"
         dict set compUnit isNative 0
-        return
+        #return
     }
 
     set var_list [lrange $def 1 end]

From e0e21d5cbfd2388af59eebe126cc4371122c8f35 Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Mon, 30 Dec 2024 09:42:49 +0100
Subject: [PATCH 36/39] some small fixes

---
 tcc4tcl_helper.tcl    |  2 +-
 tsp-clang.tcl         |  3 ++-
 tsp-compile.tcl       |  4 ++--
 tsp-expr.tcl          |  1 +
 tsp-packagehelper.tcl | 50 ++++++++++++++++++++++++++-----------------
 5 files changed, 36 insertions(+), 24 deletions(-)

diff --git a/tcc4tcl_helper.tcl b/tcc4tcl_helper.tcl
index c6f81bb..a2e5d8a 100644
--- a/tcc4tcl_helper.tcl
+++ b/tcc4tcl_helper.tcl
@@ -485,7 +485,7 @@ proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packagevers
     set $state(type) $oldtype
     
     set filename [file join $filepath "$packagename.c"]
-    set ccdirectives [::tcc4tcl::prepare_compilerdirectives $filename $::tsp::TCC_HANDLE]
+    set ccdirectives [::tcc4tcl::prepare_compilerdirectives $filename $handle]
     set fp [open $filename w]
     puts $fp "/***************** $compiletime Automatically Created with TCC4TCL Helper and maybe TSP **********************************/"
     puts $fp "/* Compiler directives are raw estimates, please adapt to given pathstructure */\n"
diff --git a/tsp-clang.tcl b/tsp-clang.tcl
index f7a4f5d..66858f5 100755
--- a/tsp-clang.tcl
+++ b/tsp-clang.tcl
@@ -266,7 +266,8 @@ proc ::tsp::lang_convert_int_string {targetVarName sourceVarName errMsg} {
         append result "if ((*rc = TSP_Util_lang_convert_int_string(interp, $sourceVarName, &$targetVarName)) != TCL_OK) \{\n"
     }
 #FIXME: see Tcl_GetInt()   but convert use Tcl_GetWideIntFromObj instead.
-    append result "    Tcl_AppendResult(interp, [::tsp::lang_quote_string $errMsg], Tcl_GetString($sourceVarName), (char *) NULL);\n"
+#    append result "    Tcl_AppendResult(interp, [::tsp::lang_quote_string $errMsg], Tcl_GetString($sourceVarName), (char *) NULL);\n"
+    append result "    Tcl_AppendResult(interp, [::tsp::lang_quote_string $errMsg], $sourceVarName, (char *) NULL);\n"
     append result "    ERROR_EXIT;\n"
     append result "\}\n"
     return $result
diff --git a/tsp-compile.tcl b/tsp-compile.tcl
index f5ca5da..c254621 100755
--- a/tsp-compile.tcl
+++ b/tsp-compile.tcl
@@ -89,7 +89,7 @@ proc ::tsp::compile_proc {file name procargs body} {
     set rc [ catch {set compileResult [::tsp::parse_body compUnit {0 end}] } errInf] 
     if {$rc != 0} {
         catch {puts [join [dict get $compUnit errors] \n]}
-        error "tsp internal error: parse_body error: $errInf"
+        error "tsp internal error parsing $name: parse_body error: $errInf"
     }
 
     set returnType [dict get $compUnit returns]
@@ -112,7 +112,7 @@ proc ::tsp::compile_proc {file name procargs body} {
     set rc [ catch {set compileResult [::tsp::parse_body compUnit {0 end}] } errInf] 
     if {$rc != 0} {
         catch {puts [join [dict get $compUnit errors] \n]}
-        error "tsp internal error: parse_body error: $errInf"
+        error "tsp internal error w parsing $name: parse_body error: $errInf"
     }
     
     lassign $compileResult bodyType bodyRhs code
diff --git a/tsp-expr.tcl b/tsp-expr.tcl
index d4db30e..03e8626 100755
--- a/tsp-expr.tcl
+++ b/tsp-expr.tcl
@@ -443,6 +443,7 @@ proc ::tsp::produce_func {compUnitDict op expr tree} {
     } elseif {[llength $tree] == 1 && [lsearch -exact $::tsp::FUNC_1ARG $op] >= 0} {
         lassign [::tsp::produce_subexpr compUnit $expr [lindex $tree 0]] firstType firstOperand
         if {[string match string* $firstType]} {
+            #::tsp::lang_convert_int_string {targetVarName $firstType errMsg}
             error "arg type cannot be string for function: $op"
         }
         if {[::tsp::typeIsBoolean $firstType]} {
diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index d56cfda..6d6bdfd 100755
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -16,20 +16,22 @@
 package require tcc4tcl
 source [file join [file dirname [info script]] tcc4tcl_helper.tcl]
 
-
 namespace eval ::tsp {
-    # added for code package making MiR
+    # added for code package making MiR, also defined and used in tsp.tcl
     variable COMPILE_PACKAGE 0
     variable PACKAGE_NAMESPACE ""
-    variable NAMESPACE_VARS ""
     variable PACKAGE_HEADER ""
-    variable TCC_HANDLE 
     variable PACKAGE_PROCS ""
+    variable NAMESPACE_VARS ""
+    variable TCC_HANDLE 
 
+    variable TSP_VERSION "-unknown-"
+    
+    # these variables are NOT to be used elsewhere in tsp
     variable PACKAGE_NAME ""
     variable PACKAGE_VERSION "1.0"
     variable PACKAGE_DIR ""
-    variable TSPPACKAGE_SPACE [file normalize [file dirname [info script]]]
+    #variable TSPPACKAGE_SPACE [file normalize [file dirname [info script]]]
     variable TCL_VERSION "TCL_VERSION"
     variable TCL_PROCS ""
     # load tcls for additional sources
@@ -98,6 +100,12 @@ proc ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0}
     set ::tsp::PACKAGE_NAMESPACE $packagenamespace
     set ::tsp::PACKAGE_VERSION $packageversion
     set ::tsp::TCL_VERSION $tclversion
+    
+    #which version of tsp did create the source? 
+    if {$::tsp::TSP_VERSION eq "-unknown-"} {
+        # try taking it from application
+        catch {set ::tsp::TSP_VERSION $::_version}
+    }
     # reset system in case
     set ::tsp::COMPILER_LOG [dict create]
     set ::tsp::COMPILED_PROCS [dict create]
@@ -110,17 +118,16 @@ proc ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0}
     set ::tsp::NAMESPACE_VARS ""
     set ::tsp::PACKAGE_INIT_PROC 0
     set ::tsp::TCL_PROCS ""
-    set ::tsp::PACKAGE_HEADER \
-        {
-/* START OF PACKAGE_HEADER */
+    set ::tsp::PACKAGE_HEADER "
+/* START OF PACKAGE_HEADER TSP (Version $::tsp::TSP_VERSION) */
 /* don't forget to declare includedir tsp-package/native/clang/ in the right way */
 #include <string.h>
 #include <tclInt.h>
-#include "TSP_cmd.c"
-#include "TSP_func.c"
-#include "TSP_util.c"
+#include \"TSP_cmd.c\"
+#include \"TSP_func.c\"
+#include \"TSP_util.c\"
 /* END OF PACKAGE_HEADER */
-    }
+    "
     
     $::tsp::TCC_HANDLE add_include_path "$::tsp::HOME_DIR/native/clang/"
     $::tsp::TCC_HANDLE add_include_path $packagename
@@ -235,6 +242,7 @@ proc ::tsp::safeEval {cmd} {
         set r [namespace eval :: "$cmd"]
         puts "Result: $r"
     } err]} {
+        interp delete sl
         ::tsp::unhook_proc
         puts "Eval Error: $err"
     }
@@ -265,29 +273,31 @@ proc ::tsp::test_packageX {packagename {callcmd ""} {shell "tclkit_8.6.12.exe"}}
         puts "Creating new exec"
         set res_name [file normalize resrc.tcl]
         set fd [open $res_name w]
+        fconfigure $fd -translation lf
         puts $fd "#!/usr/bin/tclsh"
         puts $fd "catch {console show}"
-        puts "appending auto_path with [file normalize [file dir $::tsp::PACKAGE_DIR]]"
+        puts ">>> appending auto_path with [file normalize [file dir $::tsp::PACKAGE_DIR]]"
+        puts $fd "lappend auto_path ."
         puts $fd "lappend auto_path [file normalize [file dir $::tsp::PACKAGE_DIR]]"
-        puts "Testing for [file dir $::tsp::PACKAGE_DIR] ne $packagedir"
+        #puts "Testing for [file dir $::tsp::PACKAGE_DIR] ne $packagedir"
         if {[file dir $::tsp::PACKAGE_DIR] ne $packagedir} {
-            puts "appending auto_path with $packagedir"
+            puts ">>> appending auto_path with $packagedir"
             puts $fd "lappend auto_path $packagedir"
         }
-        puts "Appending $::tsp::TSPPACKAGE_SPACE"
-        puts $fd "lappend auto_path $::tsp::TSPPACKAGE_SPACE"
-        puts "Loading package... $packagename"
+        #puts "Appending $::tsp::TSPPACKAGE_SPACE"
+        #puts $fd "lappend auto_path $::tsp::TSPPACKAGE_SPACE"
+        puts ">>> Load package... $packagename"
         puts $fd "package require $packagename"
         
         if {$callcmd ne ""} {
-            puts "Calling $callcmd"
+            puts ">>> Call $callcmd"
             puts $fd $callcmd
         }
     } err]} {
         puts "Error while preparing package $packagename\n$err"
     }
     close $fd
-    puts "Go"
+    puts ">>> Go"
     
     # shell actually hardcoded... todo implement some clever routine to find nearest kit
     # and to run under linux

From 227f819561a444b95f2319e752bb29ac13697af8 Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Wed, 29 Jan 2025 08:05:39 +0100
Subject: [PATCH 37/39] Some bugfixes

---
 tcc4tcl_helper.tcl    | 31 +++++++++++++++++++------------
 tsp-packagehelper.tcl | 39 ++++++++++++++++++++++++++++++---------
 2 files changed, 49 insertions(+), 21 deletions(-)

diff --git a/tcc4tcl_helper.tcl b/tcc4tcl_helper.tcl
index a2e5d8a..0ad38ad 100644
--- a/tcc4tcl_helper.tcl
+++ b/tcc4tcl_helper.tcl
@@ -26,6 +26,8 @@ namespace eval ::tccenv {
     variable projectincludedir  ${projectdir}/include
     variable projectlibdir      ${projectdir}/lib
     
+    variable compiletime ""
+    
     variable includes_missing ""
     
     variable EXTERNAL_COMPILERS ""
@@ -411,6 +413,19 @@ proc ::tcc4tcl::dlexport_procdefs {procdefs proclist} {
     return $exportcode
 }
 
+proc ::tcc4tcl::prepare_packagecode {handle} {
+    #
+    set DLEXPORTMAKRO $::tccenv::DLEXPORTMAKRO
+    upvar #0 $handle state
+    #modify code with dlexportmakro
+    set oldcode $state(code)
+    set newcode $DLEXPORTMAKRO
+    append newcode $oldcode
+    #append newcode [::tcc4tcl::dlexport_procdefs $state(procdefs) ""]
+    set state(code) $newcode
+    
+}
+
 proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packageversion 1.0} {tclversion TCL_VERSION}} {
     proc relTo {targetfile currentpath } {
         # Get relative path to target file from current path
@@ -459,7 +474,6 @@ proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packagevers
         }
     }
     
-    set DLEXPORTMAKRO $::tccenv::DLEXPORTMAKRO
     upvar #0 $handle state
     set oldtype "package"
     if {$state(type)!="package"} {
@@ -468,15 +482,8 @@ proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packagevers
         set state(type) "package"
     }
     
-    set compiletime [clock format [clock seconds]]
-
-    #modify code with dlexportmakro
-    set oldcode $state(code)
-    set newcode $DLEXPORTMAKRO
-    append newcode $oldcode
-    #append newcode [::tcc4tcl::dlexport_procdefs $state(procdefs) ""]
-    set state(code) $newcode
-    
+    set ::tccenv::compiletime [clock format [clock seconds]]
+#
     puts "Writing Package $packagename --> $filepath"
     set mycode [$handle code]
     
@@ -487,13 +494,13 @@ proc ::tcc4tcl::write_packagecode {handle packagename {filepath ""} {packagevers
     set filename [file join $filepath "$packagename.c"]
     set ccdirectives [::tcc4tcl::prepare_compilerdirectives $filename $handle]
     set fp [open $filename w]
-    puts $fp "/***************** $compiletime Automatically Created with TCC4TCL Helper and maybe TSP **********************************/"
+    puts $fp "/***************** $::tccenv::compiletime Automatically Created with TCC4TCL Helper and maybe TSP **********************************/"
     puts $fp "/* Compiler directives are raw estimates, please adapt to given pathstructure */\n"
     foreach {compiler ccdirective} $ccdirectives {
         puts $fp "/* for $compiler use */"
         puts $fp "/* $ccdirective */\n"
     }
-    puts $fp "/***************** $compiletime Automatically Created with TCC4TCL Helper and maybe TSP **********************************/"
+    puts $fp "/***************** $::tccenv::compiletime Automatically Created with TCC4TCL Helper and maybe TSP **********************************/"
     puts $fp $mycode
     close $fp
     return $ccdirectives
diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index 6d6bdfd..82734b8 100755
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -31,6 +31,8 @@ namespace eval ::tsp {
     variable PACKAGE_NAME ""
     variable PACKAGE_VERSION "1.0"
     variable PACKAGE_DIR ""
+    variable writepkg 1 ;# controls if any code is written out
+    variable TEST_PROC ""
     #variable TSPPACKAGE_SPACE [file normalize [file dirname [info script]]]
     variable TCL_VERSION "TCL_VERSION"
     variable TCL_PROCS ""
@@ -162,6 +164,7 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
     }
     
     ::tsp::rewrite_procnamespace
+    ::tcc4tcl::prepare_packagecode $::tsp::TCC_HANDLE
     
     if {$compiler eq ""} {
         set compiler "intern"
@@ -189,10 +192,11 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
     set cmd "::$help_proc {} $help_body"
     ::proc ::$help_proc {} $help_body
     lappend ::tsp::TCL_PROCS $help_procdef
-    
-    ::tsp::write_pkgAltTcl $::tsp::PACKAGE_NAME
-    ::tsp::write_pkgIndex $::tsp::PACKAGE_NAME
-    
+    if {$::tsp::writepkg>0} {
+        puts "writing pkg $::tsp::PACKAGE_NAME from -$::tsp::ACTSOURCE-"
+        ::tsp::write_pkgAltTcl $::tsp::PACKAGE_NAME
+        ::tsp::write_pkgIndex $::tsp::PACKAGE_NAME
+    }
     # if a source file is given
     # copy source to packagedir... if already in place, rename
     if {($::tsp::ACTSOURCE ne "")&&[file exist $::tsp::ACTSOURCE]} {
@@ -206,7 +210,7 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
             set vdiff [version:filediff $::tsp::ACTSOURCE $lastsrcname]
         }
         if {$vdiff >0} {
-            puts "Copy src to $srcname"
+            puts "Copy src $::tsp::ACTSOURCE to $srcname"
             file copy "$::tsp::ACTSOURCE" "$srcname"
         }
     }
@@ -217,7 +221,7 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
     if {$::tsp::PACKAGE_INIT_PROC>0} {
         if {$compiler in "intern memory"} {
             if {[catch {${::tsp::PACKAGE_NAME}_pkgInit} e]} {
-                puts "error: $e"
+                puts "error ${::tsp::PACKAGE_NAME}_pkgInit: $e"
             }
         }
     }
@@ -490,7 +494,12 @@ proc ::tsp::getProcIndex {packagename} {
             lassign $procdef cproc cvars cbody
             lappend helpindex "# ${::tsp::PACKAGE_NAMESPACE}::$cproc $cvars"
         }
+        if {$procname eq "${packagename}_pkgInit"} {
+            set ::tsp::PACKAGE_INIT_PROC 1
+            puts "Init via $procname"
+        }
     }
+
     lappend helpindex ""
     lappend helpindex "# TCL Procs "
     lappend helpindex ""
@@ -499,6 +508,10 @@ proc ::tsp::getProcIndex {packagename} {
     foreach tcldef $tclpr {
         lassign $tcldef cproc cvars cbody
         lappend helpindex [string map {\n "."} "# $cproc $cvars"]
+        if {$cproc eq "${packagename}_pkgInit"} {
+            set ::tsp::PACKAGE_INIT_PROC 1
+            puts "Init via $cproc"
+        }
     }
     return [join $helpindex \n]
 }
@@ -561,7 +574,7 @@ proc ::tsp::write_pkgIndex {packagename} {
         append pkgloadlib "     ${packagename}_loadext \$dir\n"
     }
     if {$::tsp::PACKAGE_PROCS ne ""} {
-        append pkgloadlib "     if {\[catch {load \[file join \$dir \$packagename\[info sharedlibextension\]\]} err\]} {\n"
+        append pkgloadlib "     if {\[catch {load \[file join \$dir \$packagename\[info sharedlibextension\]\] \$packagename} err\]} {\n"
         append pkgloadlib "         source  \[file join \$dir \${packagename}.tclprocs.tcl\]\n"
         append pkgloadlib "     }\n"
     }
@@ -641,6 +654,7 @@ proc ::tsp::write_pkgAltTcl {packagename} {
         lassign $procdef procname procargs procbody
         if {$procname eq "${packagename}_pkgInit"} {
             set ::tsp::PACKAGE_INIT_PROC 1
+            puts "Init via $procname"
         }
         if {$::tsp::PACKAGE_NAMESPACE ne ""} {
             set procname "::${::tsp::PACKAGE_NAMESPACE}::$procname"
@@ -672,6 +686,7 @@ proc ::tsp::write_pkgAltTcl {packagename} {
         lassign $procdef procname procargs procbody
         if {$procname eq "${packagename}_pkgInit"} {
             set ::tsp::PACKAGE_INIT_PROC 1
+            puts "Init via $procname"
         }
         puts $fd "proc ${procname} {$procargs} {$procbody}\n"
     }
@@ -762,7 +777,7 @@ proc ::tsp::compile_package {packagename {compiler tccwin32}} {
     if {[llength $::errorCode]>1} {
         puts "Compiling seems to have errors, execution halted"
         puts "errorCode $::errorCode"
-        return -code error
+        return -code error $err
     }
     return 1
 }
@@ -870,8 +885,10 @@ proc version:filediff {file1 file2 {cmdEqual {version:cmdEqual}} {cmdAdd {versio
 proc version:cmdEqual {txt line} {
 }
 proc version:cmdAdd {txt line} {
+    if {[string trim $txt]!=""} {
         append ::actdiff "$line: +$txt\n";update
         incr ::afilediffs
+    }
 }
 proc version:cmdDel {txt line} {
     if {[string trim $txt]!=""} {
@@ -879,6 +896,10 @@ proc version:cmdDel {txt line} {
         incr ::afilediffs
     }
 }
-
+proc version:clear {} {
+    set ::lfilediffs ""
+    set ::tfilediffs ""
+    set ::cfilediffs 0
+}
 #----------------------------------- Code to remove -----------------------------------------
 

From 7ad2e60fec680985a91d18242456e4d9af479642 Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Sun, 16 Feb 2025 18:22:52 +0100
Subject: [PATCH 38/39] some small bugfixes added tsp::tclwrap as wrapper for
 tcc4tcl::tclwrap

---
 tsp-packagehelper.tcl | 31 ++++++++++++++++++++++++++++---
 1 file changed, 28 insertions(+), 3 deletions(-)

diff --git a/tsp-packagehelper.tcl b/tsp-packagehelper.tcl
index 82734b8..f9298e3 100755
--- a/tsp-packagehelper.tcl
+++ b/tsp-packagehelper.tcl
@@ -99,7 +99,7 @@ proc ::tsp::init_package {packagename {packagenamespace ""} {packageversion 1.0}
     }
     set ::tsp::COMPILE_PACKAGE 1
     set ::tsp::PACKAGE_NAME $packagename
-    set ::tsp::PACKAGE_NAMESPACE $packagenamespace
+    set ::tsp::PACKAGE_NAMESPACE [string trim $packagenamespace :]; # remove prepending/trailing :: 
     set ::tsp::PACKAGE_VERSION $packageversion
     set ::tsp::TCL_VERSION $tclversion
     
@@ -230,6 +230,31 @@ proc ::tsp::finalize_package {{packagedir ""} {compiler none}} {
         
 }
 
+proc ::tsp::tclwrap {name {adefs {}} {rtype void} {cname ""}} {
+    # this is a trampoline for tcc4tcls tclwrap routine adding the namespace
+    if {[namespace exists ::${::tsp::PACKAGE_NAMESPACE}]>0} {
+        # prepend package_namespace to name
+        # first clean up the nampespace_identifeier
+        set vname "::${::tsp::PACKAGE_NAMESPACE}::${name}"
+        if {[info command $vname]==$vname} {
+            set name $vname
+        }
+    }
+    $::tsp::TCC_HANDLE tclwrap $name $adefs $rtype $cname
+}
+proc ::tsp::tclwrap_eval {name {adefs {}} {rtype void} {cname ""}} {
+    # this is a trampoline for tcc4tcls tclwrap routine adding the namespace
+    if {[namespace exists ::${::tsp::PACKAGE_NAMESPACE}]>0} {
+        # prepend package_namespace to name
+        set vname "::${::tsp::PACKAGE_NAMESPACE}::${name}"
+        if {[info command $vname]==$vname} {
+            set name $vname
+        }
+    }
+    $::tsp::TCC_HANDLE tclwrap_eval $name $adefs $rtype $cname
+}
+
+
 proc ::tsp::addExternalCompiler {compiler ccOptions exeDir exeFile {compilertype gccwin32}} {
     # add external compiler to list EXTERNAL_COMPILERS
     # $compiler:        compilername cc
@@ -567,10 +592,10 @@ proc ::tsp::write_pkgIndex {packagename} {
     }
     
     set pkgloadlib  "proc ${packagename}_loadlib {dir packagename} {\n"
-    if {($loadextlibs ne "")} {
+    if {($loadextlibs ne "")||($::tsp::LOAD_DLLS ne "")} {
         append pkgloadlib "     ${packagename}_loadextdlls \$dir\n"
     }
-    if {($loadextlibs ne "")||($::tsp::LOAD_DLLS ne "")} {
+    if {($loadextlibs ne "")||($::tsp::LOAD_TCLS ne "")} {
         append pkgloadlib "     ${packagename}_loadext \$dir\n"
     }
     if {$::tsp::PACKAGE_PROCS ne ""} {

From 445e951af8b05a0d065472fd0683deaec4400a28 Mon Sep 17 00:00:00 2001
From: MichaelMiR01 <project.draco@gmx.net>
Date: Thu, 29 May 2025 11:28:42 +0200
Subject: [PATCH 39/39] some bugfixes

---
 native/clang/TSP_util.c   | 36 +++++++++++++++++++++++++++++++++++-
 native/clang/backup_n.tcl | 23 -----------------------
 tsp-clang.tcl             |  3 +--
 tsp-generate-control.tcl  |  6 +++---
 tsp-generate-set.tcl      | 11 ++++++++---
 tsp-generate.tcl          | 19 +++++++++++++++----
 6 files changed, 62 insertions(+), 36 deletions(-)
 delete mode 100755 native/clang/backup_n.tcl

diff --git a/native/clang/TSP_util.c b/native/clang/TSP_util.c
index a17879f..60769bc 100755
--- a/native/clang/TSP_util.c
+++ b/native/clang/TSP_util.c
@@ -1,7 +1,38 @@
 #ifndef _TCL
 #include <tcl.h>
 #endif
-
+int TSP_debug(Tcl_Interp* interp, char const *format, ...) {
+    /* Helper for Debugging*/
+    char __buf [4096];
+    va_list aptr;
+    int ret;
+    va_start(aptr, format);
+    ret = vsnprintf(__buf, 4096, format, aptr);
+    va_end(aptr);
+    // compensate for surplus linebreaks, sincs puts will already write one
+    if(ret<0) return EOF;
+    if(ret>4096) ret=4096;
+    if(__buf[ret-1]=='\n') __buf[ret-1]=0;
+    Tcl_Interp* ip =  interp; 
+    if (ip==NULL) Tcl_Panic("No interp found to call tcl routine!");
+    mod_Tcl_errorCode=0;
+    Tcl_Obj*  argObjvArray [2];
+    Tcl_Obj* funcname = Tcl_NewStringObj("puts",-1);
+    Tcl_IncrRefCount(funcname);
+    argObjvArray[0] = funcname;
+    Tcl_Obj* target_1 = Tcl_NewStringObj(__buf,-1);
+    Tcl_IncrRefCount(target_1);
+    argObjvArray[1] = target_1;
+    int rs = Tcl_EvalObjv(ip, 2, argObjvArray, 0);
+    if(funcname!=NULL) Tcl_DecrRefCount(funcname);
+    if(target_1 != NULL) Tcl_DecrRefCount(target_1);
+    if(rs !=TCL_OK) {
+        Tcl_Eval (ip, "puts {Error evaluating TCL-Function puts}; puts $errorInfo; flush stdout;");
+        return EOF;
+    }
+    Tcl_DoOneEvent(TCL_DONT_WAIT|TCL_ALL_EVENTS);
+    return 1; 
+}
 
 /*********************************************************************************************/
 /* convert to an int from a string */
@@ -224,9 +255,12 @@ TSP_Util_lang_assign_var_var(Tcl_Obj* targetVarName, Tcl_Obj* sourceVarName) {
 
 /*********************************************************************************************/
 /* assign an array & element from a var */
+
 TSP_REMOVABLE int
 TSP_Util_lang_assign_array_var(Tcl_Interp* interp, Tcl_Obj* targetArrayVar, Tcl_Obj* targetIdxVar, Tcl_Obj* var) {
     Tcl_Obj* obj;
+    if (var==NULL) {return TCL_ERROR;};
+    //debug(interp,"TSP_Util_lang_assign_array_var %p %p %p\n",targetArrayVar,targetIdxVar,var);
     obj = Tcl_ObjSetVar2(interp, targetArrayVar, targetIdxVar, var, TCL_LEAVE_ERR_MSG);
     if (obj == NULL) {
         return TCL_ERROR;
diff --git a/native/clang/backup_n.tcl b/native/clang/backup_n.tcl
deleted file mode 100755
index 82fed8a..0000000
--- a/native/clang/backup_n.tcl
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/usr/bin/tclsh
-## exec tclkit
-## Backup
-
-set t [clock format [clock seconds] -format "%Y-%m-%d_%H-%M"]
-catch {console show}
-file mkdir "./cvs"
-foreach f0 [glob -nocomplain [file join "./" *]] {
-    if {[file isfile $f0]} {
-        set f [file tail $f0]
-        set n [file rootname $f]
-        set x [file extension $f]
-        set t0 [file mtime $f0]
-        set ts0 [clock format $t0 -format "%Y-%m-%d_%H-%M"]
-        #if {$f!=[file tail $::argv0]} {
-            set f1 "./cvs/$n.$ts0$x"
-            if {![file exists $f1]} { 
-                puts "copy $f0 $f1"
-                file copy $f0 $f1
-            }
-        #}
-    }
-}
diff --git a/tsp-clang.tcl b/tsp-clang.tcl
index 66858f5..9f1af37 100755
--- a/tsp-clang.tcl
+++ b/tsp-clang.tcl
@@ -675,8 +675,7 @@ proc ::tsp::lang_assign_var_var {targetVarName sourceVarName {preserve 1}} {
 #   which is preserved and released
 #
 proc ::tsp::lang_assign_array_var {targetArrayVar targetIdxVar var} {
-    append result "/* ::tsp::lang_assign_array_var */\n"
-
+    append result "/* ::tsp::lang_assign_array_var $targetArrayVar $targetIdxVar $var */\n"
     append result "TSP_Util_lang_assign_array_var(interp, $targetArrayVar, $targetIdxVar, $var);\n"
     return $result
 }
diff --git a/tsp-generate-control.tcl b/tsp-generate-control.tcl
index b12edcf..0f723ca 100755
--- a/tsp-generate-control.tcl
+++ b/tsp-generate-control.tcl
@@ -19,14 +19,14 @@ proc ::tsp::gen_command_for {compUnitDict tree} {
 
     set rawtext [::tsp::parse_getstring compUnit [lindex $tree 1]]
     if {[string range $rawtext 0 0] ne "\{"} {
-        ::tsp::addError compUnit "start code argument not a braced word"
+        ::tsp::addError compUnit "start code argument not a braced word $rawtext"
         return [list void "" ""]
     }
     set pretext [lindex $rawtext 0]
 
     set rawtext [::tsp::parse_getstring compUnit [lindex $tree 2]]
     if {[string range $rawtext 0 0] ne "\{"} {
-        ::tsp::addError compUnit "test expr argument not a braced expression"
+        ::tsp::addError compUnit "test expr argument not a braced expression $rawtext"
         return [list void "" ""]
     }
     set exprtext [lindex $rawtext 0]
@@ -112,7 +112,7 @@ proc ::tsp::gen_command_while {compUnitDict tree} {
     # get expr component, make sure it is braced
     set rawtext [::tsp::parse_getstring compUnit [lindex $tree 1]]
     if {[string range $rawtext 0 0] ne "\{"} {
-        ::tsp::addError compUnit "expr argument not a braced expression"
+        ::tsp::addError compUnit "expr argument not a braced expression $rawtext"
         return [list void "" ""]
     }
     set exprtext [lindex $rawtext 0]
diff --git a/tsp-generate-set.tcl b/tsp-generate-set.tcl
index 9054de4..67adbf4 100755
--- a/tsp-generate-set.tcl
+++ b/tsp-generate-set.tcl
@@ -659,7 +659,7 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
     }
 
     set targetPre [::tsp::var_prefix $targetVarName]
-    append result "\n/***** ::tsp::gen_assign_var_string_interpolated_string */\n"
+    append result "\n/***** ::tsp::gen_assign_var_string_interpolated_string targetType $targetType */\n"
     
     set tmp [::tsp::get_tmpvar compUnit string]
     set tmp2 ""
@@ -671,7 +671,8 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
     # fix: why is this not reset?
     if {$targetType eq "string"} {
         if {$targetPre!=""} {
-            append result  "Tcl_DStringSetLength($targetPre$targetVarName,0);\n"
+            append result [::tsp::lang_assign_empty_zero $targetPre$targetVarName string]
+            #append result  "/* DEBUG Tcl_DStringSetLength($targetPre$targetVarName,0);*/\n"
         }
     }
         
@@ -716,6 +717,7 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
             }
             text_array_idxvar - array_idxvar {
                  append code "//Parsing Array $compType in $component of $sourceComponents\n"
+                 puts "//Parsing Array $compType in $component of $sourceComponents\n"
                  #::tsp::addWarning compUnit "$compType not implemented $component $sourceComponents"
                  #append code "//Parsing $component in $sourceComponents\n"
 				set tmp_s [::tsp::get_tmpvar compUnit string]
@@ -746,12 +748,14 @@ proc ::tsp::gen_assign_var_string_interpolated_string {compUnitDict targetVarNam
 				        append code "//Missing source in $sourceComponents\n"
 				        continue
 				    } else {
+				        error "DEBUG here, this is an unknown testcase??? 2025-04-18"
                         #::tsp::addWarning compUnit "set arg 2 interpolated string should not contain $compType as $sourceText in $sourceComponents, only commands, text, backslash, or scalar variables\n"
                         set newsource "[lindex $sourceComponents 1]("
                         #append code "// Convert |$newsource|  to $tmp via $tmp_s\n"
                         append code [::tsp::lang_assign_string_const $tmp $newsource]
                         append code [::tsp::lang_append_string $tmp $tmp_s]
-                        append code "Tcl_DStringAppend($tmp,\")\",-1);\n"
+                        append code [::tsp::lang_append_string $tmp "\")\""]
+                        append code "// DEBUG Tcl_DStringAppend($tmp,\")\",-1);\n//DEBUG Appended additional braces\n"
                         set doreturn 1
                     }
 				}
@@ -899,6 +903,7 @@ proc ::tsp::gen_assign_array_scalar {compUnitDict targetVarName targetArrayIdxte
             append code [::tsp::lang_assign_var_$sourceType $value $pre$sourceVarName]
         } else {
             # it's a native var, use a shadow var
+            ::tsp::setDirty compUnit $sourceVarName
             lassign [::tsp::getCleanShadowVar compUnit $sourceVarName] value shadowCode
             append code $shadowCode
         }
diff --git a/tsp-generate.tcl b/tsp-generate.tcl
index 1f05b87..311fbea 100755
--- a/tsp-generate.tcl
+++ b/tsp-generate.tcl
@@ -800,22 +800,33 @@ proc ::tsp::mkComment {text {len 40} {rawOnly 0}} {
 # get a clean shadow var for a native variable
 # generates code to set the shadow var if native variable is currently dirty
 # returns list of {var code}
+# BUG FIXME This does not really work, if the shadow var gets set clean in a different code-path!
+# HACK At least inserted a test if shadowVar is NULL
+# to avoid crashing fron NULL Pointer Deref
 
 proc ::tsp::getCleanShadowVar {compUnitDict nativeVar} {
     upvar $compUnitDict compUnit
     set shadowVar [::tsp::get_tmpvar compUnit var $nativeVar]
+    set argVarComponents [list [list text $shadowVar $shadowVar]]
+    set sourceComponents [list [list scalar $nativeVar]]
+    set setTree ""
     if {[lsearch [::tsp::getCleanList compUnit] $nativeVar] == -1} {
         # var is not clean or not present, generate an assignment
-        set argVarComponents [list [list text $shadowVar $shadowVar]]
-        set sourceComponents [list [list scalar $nativeVar]]
-        set setTree ""
         set result "\n/* set shadow variable $nativeVar */"
         append result [lindex [::tsp::produce_set compUnit $setTree $argVarComponents $sourceComponents] 2]
         # mark the native variable clean
-        ::tsp::setDirty compUnit $nativeVar 0
+# BUG FIXME This does not really work, if the shadow var gets set clean in a different code-path!
+# REMOVED, since it broke in case of multiple loops
+# heapsort failed dramatically
+        # ::tsp::setDirty compUnit $nativeVar 0
     } else {
         # var is clean no need to re-assign
         set result "/* shadow variable $nativeVar marked as clean */\n"
+        # prevent, that it's null
+        append result "if($shadowVar==NULL) {\n"
+        append result [lindex [::tsp::produce_set compUnit $setTree $argVarComponents $sourceComponents] 2]
+        append result "}\n"
+        
     }
 
     return [list $shadowVar $result]