remove vcpkg installation added by mistake

22 files changed, 0 insertions, 41357 deletions

diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/LICENSE b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/LICENSE
deleted file mode 100644
index 4fe636c..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/LICENSE
+++ /dev/null
@@ -1,35 +0,0 @@
-Unless explicitly stated, all files which form part of autosetup
-are released under the following license:
-
----------------------------------------------------------------------
-autosetup - A build environment "autoconfigurator"
-
-Copyright (c) 2010-2011, WorkWare Systems <http://workware.net.au/>
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following
-   disclaimer in the documentation and/or other materials
-   provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE WORKWARE SYSTEMS ``AS IS'' AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WORKWARE
-SYSTEMS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-The views and conclusions contained in the software and documentation
-are those of the authors and should not be interpreted as representing
-official policies, either expressed or implied, of WorkWare Systems.
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/README.autosetup b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/README.autosetup
deleted file mode 100644
index 3952980..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/README.autosetup
+++ /dev/null
@@ -1,11 +0,0 @@
-README.autosetup created by autosetup v0.7.2
-
-This is the autosetup directory for a local install of autosetup.
-It contains autosetup, support files and loadable modules.
-
-*.tcl files in this directory are optional modules which
-can be loaded with the 'use' directive.
-
-*.auto files in this directory are auto-loaded.
-
-For more information, see https://msteveb.github.io/autosetup/
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/README.md b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/README.md
deleted file mode 100644
index ac01308..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/README.md
+++ /dev/null
@@ -1,464 +0,0 @@
-Maintaining Autosetup in the SQLite Tree
-========================================================================
-
-This document provides some tips and reminders for the SQLite
-developers regarding using and maintaining the [Autosetup][]-based
-build infrastructure. It is not an [Autosetup][] reference.
-
-**Table of Contents**:
-
-- [Autosetup API Reference](#apiref)
-- [API Tips](#apitips)
-- [Ensuring TCL Compatibility](#tclcompat)
-- [Design Conventions](#conventions)
-  - Symbolic Names of Feature Flags
-  - Do Not Update Global Shared State
-- [Updating Autosetup](#updating)
-  - ***[Patching Autosetup for Project-local changes](#patching)***
-- [Branch-specific Customization](#branch-customization)
-
-
-------------------------------------------------------------------------
-
-<a name="apiref"></a>
-Autosetup API Reference
-========================================================================
-
-The Autosetup API is quite extensive and can be read either in
-the [files in the `autosetup` dir](/dir/autosetup) or using:
-
->
-```
-$ ./configure --reference | less
-```
-
-That will include any docs from any TCL files in the `./autosetup` dir
-which contain certain (simple) markup defined by autosetup.
-
-This project's own configuration-related TCL code is spread across the
-following files:
-
-- [proj.tcl][]: project-agnostic utility code for autosetup-driven
-  projects. This file is designed to be shared between this project,
-  other projects managed under the SQLite/Hwaci umbrella
-  (e.g. Fossil), and personal projects of SQLite's developers.  It is
-  essentially an amalgamation of a decade's worth of autosetup-related
-  utility code.
-- [sqlite-config.tcl][]: utility code which is too project-specific
-  for `proj.tcl`. We split this out of `auto.def` so that it can be
-  used by both `auto.def` and...
-- [auto.def][]: the primary driver for the `./configure` process.
-  When we talk about "the configure script," we're technically
-  referring to this file, though it actually contains very little
-  of the TCL code.
-- [autoconf/auto.def][]: the main driver script for the "autoconf"
-  bundle's configure script. It is essentially a slightly trimmed-down
-  version of the main `auto.def` file. The `autoconf` dir was ported
-  from the Autotools to Autosetup in the 3.49.0 dev cycle but retains
-  the "autoconf" name to minimize downstream disruption.
-
-
-<a name="apitips"></a>
-Autosetup API Tips
-========================================================================
-
-This section briefly covers only APIs which are frequently useful in
-day-to-day maintenance and might not be immediately recognized as such
-from a casual perusal of the relevant TCL files. The complete docs of
-those with `proj-` prefix can be found in [proj.tcl][] and those with
-an `sqlite-` prefix are in [sqlite-config.tcl][]. The others are part
-of Autosetup's core packages and are scattered around [the TCL files
-in ./autosetup](/dir/autosetup).
-
-In (mostly) alphabetical order:
-
-- **`file-isexec filename`**\  
-  Should be used in place of `[file executable]`, as it will also
-  check for `${filename}.exe` on Windows platforms. However, on such
-  platforms it also assumes that _any_ existing file is executable.
-
-- **`get-env VAR ?default?`**\  
-  Will fetch an "environment variable" from the first of either: (1) a
-  KEY=VALUE passed to the configure script or (2) the system's
-  environment variables. Not to be confused with `getenv`, which only
-  does the latter and is rarely, if ever, useful in this tree.
-  - **`proj-get-env VAR ?default?`**\  
-    Works like `get-env` but will, if that function finds no match,
-    look for a file named `./.env-$VAR` and, if found, return its
-    trimmed contents. This can be used, e.g., to set a developer's
-    local preferences for the default `CFLAGS`.\  
-    Tip: adding `-O0` to `.env-CFLAGS` reduces rebuild times
-    considerably at the cost of performance in `make devtest` and the
-    like.
-
-- **`proj-fatal msg`**\  
-  Emits `$msg` to stderr and exits with non-zero. Its differences from
-  autosetup's `user-error` are purely cosmetic.
-
-- **`proj-if-opt-truthy flag thenScript ?elseScript?`**\  
-  Evals `thenScript` if the given `--flag` is truthy, else it
-  evals the optional `elseScript`.
-
-- **`proj-indented-notice ?-error? ?-notice? msg`**\  
-  Breaks its `msg` argument into lines, trims them, and emits them
-  with consistent indentation. Exactly how it emits depends on the
-  flags passed to it (or not), as covered in its docs. This will stick
-  out starkly from normal output and is intended to be used only for
-  important notices.
-
-- **`proj-opt-truthy flag`**\  
-  Returns 1 if `--flag`'s value is "truthy," i.e. one of (1, on,
-  enabled, yes, true).
-
-- **`proj-opt-was-provided FLAG`**\  
-  Returns 1 if `--FLAG` was explicitly provided to configure,
-  else 0. This distinction can be used to determine, e.g., whether
-  `--with-readline` was provided or whether we're searching for
-  readline by default. In the former case, failure to find it should
-  be treated as fatal, where in the latter case it's not.\  
-  Unlike most functions which deal with `--flags`, this one does not
-  validate that `$FLAG` is a registered flag so will not fail fatally
-  if `$FLAG` is not registered as an Autosetup option.
-
-- **`proj-val-truthy value`**\  
-  Returns 1 if `$value` is "truthy," See `proj-opt-truthy` for the definition
-  of "truthy."
-
-- **`proj-warn msg`**\  
-  Emits `$msg` to stderr. Closely-related is autosetup's `user-notice`
-  (described below).
-
-- **`sqlite-add-feature-flag ?-shell? FLAG...`**\  
-  Adds the given feature flag to the CFLAGS which are specific to
-  building libsqlite3. It's intended to be passed one or more
-  `-DSQLITE_ENABLE_...`, or similar, flags. If the `-shell` flag is
-  used then it also passes its arguments to
-  `sqlite-add-shell-opt`. This is a no-op if `FLAG` is not provided or
-  is empty.
-
-- **`sqlite-add-shell-opt FLAG...`**\  
-  The shell-specific counterpart of `sqlite-add-feature-flag` which
-  only adds the given flag(s) to the CLI-shell-specific CFLAGS.
-
-- **`sqlite-configure BUILD-NAME {script}`**\  
-  This is where all configure `--flags` are defined for all known
-  build modes ("canonical" or "autoconf"). After processing all flags,
-  this function runs `$script`, which contains the build-mode-specific
-  configuration bits, and then runs any finalization bits which are
-  common to all build modes. The `auto.def` files are intended to contain
-  exactly two commands:
-  `use sqlite-config; sqlite-configure BUILD-NAME {script}`
-
-- **`user-notice msg`**\  
-  Queues `$msg` to be sent to stderr, but does not emit it until
-  either `show-notices` is called or the next time autosetup would
-  output something (it internally calls `show-notices`). This can be
-  used to generate warnings between a "checking for..." message and
-  its resulting "yes/no/whatever" message in such a way as to not
-  spoil the layout of such messages.
-
-
-<a name="tclcompat"></a>
-Ensuring TCL Compatibility
-========================================================================
-
-One of the significant benefits of using Autosetup is that (A) this
-project uses many TCL scripts in the build process and (B) Autosetup
-comes with a TCL interpreter named [JimTCL][].
-
-It is important that any TCL files used by the configure process and
-makefiles remain compatible with both [JimTCL][] and the canonical
-TCL. Though JimTCL has outstanding compatibility with canonical TCL,
-it does have a few corners with incompatibilities, e.g. regular
-expressions. If a script runs in JimTCL without using any
-JimTCL-specific features, then it's a certainty that it will run in
-canonical TCL as well. The opposite, however, is not _always_ the
-case.
-
-When [`./configure`](/file/configure) is run, it goes through a
-bootstrapping process to find a suitable TCL with which to run the
-autosetup framework. The first step involves [finding or building a
-TCL shell](/file/autosetup/autosetup-find-tclsh).  That will first
-search for an available `tclsh` (under several common names,
-e.g. `tclsh8.6`) before falling back to compiling the copy of
-`jimsh0.c` included in the source tree. i.e. it will prefer to use a
-system-installed TCL for running the configure script. Once it finds
-(or builds) a TCL shell, it then runs [a sanity test to ensure that
-the shell is suitable](/file/autosetup/autosetup-test-tclsh) before
-using it to run the main autosetup app.
-
-There are two simple ways to ensure that running of the configure
-process uses JimTCL instead of the canonical `tclsh`, and either
-approach provides equally high assurances about configure script
-compatibility across TCL implementations:
-
-1. Build on a system with no `tclsh` installed in the `$PATH`. In that
-   case, the configure process will fall back to building the in-tree
-   copy of JimTCL.
-
-2. Manually build `./jimsh0` in the top of the checkout with:\  
-   `cc -o jimsh0 autosetup/jimsh0.c`\  
-   With that in place, the configure script will prefer to use that
-   before looking for a system-level `tclsh`. Be aware, though, that
-   `make distclean` will remove that file.
-
-**Note that `./jimsh0` is distinctly different from the `./jimsh`**
-which gets built for code-generation purposes.  The latter requires
-non-default build flags to enable features which are
-platform-dependent, most notably to make its `[file normalize]` work.
-This means, for example, that the configure script and its utility
-APIs must not use `[file normalize]`, but autosetup provides a
-TCL-only implementation of `[file-normalize]` (note the dash) for
-portable use in the configure script. Contrariwise, code-generation
-scripts invoked via `make` may use `[file normalize]`, as they'll use
-`./jimsh` or `tclsh` instead of `./jimsh0`.
-
-
-Known TCL Incompatibilities
-------------------------------------------------------------------------
-
-A summary of known incompatibilities in JimTCL
-
-- **CRNL line endings**: prior to 2025-02-05 `fconfigure -translation ...`
-  was a no-op in JimTCL, and it emits CRNL line endings by default on
-  Windows.  Since then, it supports `-translation binary`, which is
-  close enough to `-translation lf` for our purposes. When working
-  with files using the `open` command, it is important to use mode
-  `"rb"` or `"wb"`, as appropriate, so that the output does not get
-  CRNL-mangled on Windows.
-
-- **`file copy`** does not support multiple source files. See
-  [](/info/61f18c96183867fe) for a workaround.
-
-- **Regular expressions**:
-
-  - Patterns treat `\nnn` octal values as back-references (which it
-    does not support). Those can be reformulated as demonstrated in
-    [](/info/aeac23359bb681c0).
-
-  - `regsub` does not support the `\y` flag. A workaround is demonstrated
-    in [](/info/c2e5dd791cce3ec4).
-
-
-<a name="conventions"></a>
-Design Conventions
-========================================================================
-
-This section describes the motivations for the most glaring of the
-build's design decisions, in particular how they deviate from
-historical, or even widely-conventional, practices.
-
-Symbolic Names of Feature Flags
-------------------------------------------------------------------------
-
-Historically, the project's makefile has exclusively used
-`UPPER_UNDERSCORE` form for makefile variables. This build, however,
-primarily uses `X.y` format, where `X` is often a category label,
-e.g. `CFLAGS`, and `y` is the specific instance of that category,
-e.g. `CFLAGS.readline`.
-
-When the configure script exports flags for consumption by filtered
-files, e.g. [Makefile.in][] and the generated
-`sqlite_cfg.h`, it does so in the more conventional `X_Y` form because
-those flags get exported as as C `#define`s to `sqlite_cfg.h`, where
-dots are not permitted.
-
-The `X.y` convention is used in the makefiles primarily because the
-person who did the initial port finds that considerably easier on the
-eyes and fingers. In practice, the `X_Y` form of such exports is used
-exactly once in [Makefile.in][], where it's translated from `@X_Y@`
-into into `X.y` form for consumption by [Makefile.in][] and
-[main.mk][]. For example:
-
->
-```
-LDFLAGS.shobj = @SHOBJ_LDFLAGS@
-LDFLAGS.zlib = @LDFLAGS_ZLIB@
-LDFLAGS.math = @LDFLAGS_MATH@
-```
-
-(That first one is defined by autosetup, and thus applies "LDFLAGS" as
-the suffix rather than the prefix. Which is more legible is a matter
-of taste, for which there is no accounting.)
-
-
-Do Not Update Global Shared State
-------------------------------------------------------------------------
-
-In both the legacy Autotools-driven build and common Autosetup usage,
-feature tests performed by the configure script may amend global flags
-such as `LIBS`, `LDFLAGS`, and `CFLAGS`[^as-cflags].  That's
-appropriate for a makefile which builds a single deliverable, but less
-so for makefiles which produce multiple deliverables. Drawbacks of
-that approach include:
-
-- It's unlikely that every single deliverable will require the same
-  core set of those flags.
-- It can be difficult to determine the origin of any given change to
-  that global state because those changes are hidden behind voodoo
-  performed outside the immediate visibility of the configure script's
-  maintainer.
-- It can force the maintainers of the configure script to place tests
-  in a specific order so that the resulting flags get applied at
-  the correct time and/or in the correct order.\  
-  (A real-life example: before the approach described below was taken
-  to collecting build-time flags, the test for `-rpath` had to come
-  _after_ the test for zlib because the results of the `-rpath` test
-  implicitly modified global state which broke the zlib feature
-  test. Because the feature tests no longer (intentionally) modify
-  shared global state, that is not an issue.)
-
-In this build, cases where feature tests modify global state in such a
-way that it may impact later feature tests are either (A) very
-intentionally defined to do so (e.g. the `--with-wasi-sdk` flag has
-invasive side-effects) or (B) are oversights (i.e. bugs).
-
-This tree's [configure script][auto.def], [utility APIs][proj.tcl],
-[Makefile.in][], and [main.mk][] therefore strive to separate the
-results of any given feature test into its own well-defined
-variables. For example:
-
-- The linker flags for zlib are exported from the configure script as
-  `LDFLAGS_ZLIB`, which [Makefile.in][] and [main.mk][] then expose as
-  `LDFLAGS.zlib`.
-- `CFLAGS_READLINE` (a.k.a. `CFLAGS.readline`) contains the `CFLAGS`
-  needed for including `libreadline`, `libedit`, or `linenoise`, and
-  `LDFLAGS_READLINE` (a.k.a. `LDFLAGS.readline`) is its link-time
-  counterpart.
-
-It is then up to the Makefile to apply and order the flags however is
-appropriate.
-
-At the end of the configure script, the global `CFLAGS` _ideally_
-holds only flags which are either relevant to all targets or, failing
-that, will have no unintended side-effects on any targets. That said:
-clients frequently pass custom `CFLAGS` to `./configure` or `make` to
-set library-level feature toggles, e.g. `-DSQLITE_OMIT_FOO`, in which
-case there is no practical way to avoid "polluting" the builds of
-arbitrary makefile targets with those. _C'est la vie._
-
-
-[^as-cflags]: But see this article for a detailed discussion of how
-    autosetup currently deals specifically with CFLAGS:
-    <https://msteveb.github.io/autosetup/articles/handling-cflags/>
-
-
-<a name="updating"></a>
-Updating Autosetup
-========================================================================
-
-Updating autosetup is, more often than not, painless. It requires having
-a checked-out copy of [the autosetup git repository][autosetup-git]:
-
->
-```
-$ git clone https://github.com/msteveb/autosetup
-$ cd autosetup
-# Or, if it's already checked out:
-$ git pull
-```
-
-Then, from the top-most directory of an SQLite checkout:
-
->
-```
-$ /path/to/autosetup-checkout/autosetup --install .
-$ fossil status # show the modified files
-```
-
-Unless the upgrade made any incompatible changes (which is exceedingly
-rare), that's all there is to it.  After that's done, **apply a patch
-for the change described in the following section**, test the
-configure process, and check it in.
-
-<a name="patching"></a>
-Patching Autosetup for Project-local Changes
-------------------------------------------------------------------------
-
-The autosetup files require the following patches after updating
-from their upstream sources:
-
-### `--debug` flag
-
-Autosetup reserves the flag name **`--debug`** for its own purposes,
-and its own special handling of `--enable-...` flags makes `--debug`
-an alias for `--enable-debug`. As this project has a long history of
-using `--enable-debug`, we patch autosetup to use the name
-`--autosetup-debug` in place of `--debug`. That requires (as of this
-writing) four small edits in
-[/autosetup/autosetup](/file/autosetup/autosetup), as demonstrated in
-[check-in 3296c8d3](/info/3296c8d3).
-
-If autosetup is upgraded and this patch is _not_ applied the invoking
-`./configure` will fail loudly because of the declaration of the
-`debug` flag in `auto.def` - duplicated flags are not permitted.
-
-### Fail on `malloc()` error
-
-See [check-in 72c8a5b94cdf5d](/info/72c8a5b94cdf5d).
-
-
-<a name="branch-customization"></a>
-Branch-specific Customization
-========================================================================
-
-Certain vendor-specific branches require slight configure script
-customization. Rather than editing `sqlite-config.tcl` for this,
-which frequently leads to merge conflicts, the following approach
-is recommended:
-
-In the vendor-specific branch, create a file named
-`autosetup/sqlite-custom.tcl`.
-
-That file should contain the following content...
-
-If flag customization is required, add:
-
->
-```
-proc sqlite-custom-flags {} {
-  # If any existing --flags require different default values
-  # then call:
-  options-defaults {
-    flag-name new-default-value
-    ...
-  }
-  # ^^^ That will replace the default value but will not update
-  # the --help text, which may lead to some confusion:
-  # https://github.com/msteveb/autosetup/issues/77
-
-  return {
-   {*} {
-     new-flag-name => {Help text}
-     ...
-   }
-  }; #see below
-}
-```
-
-That function must return either an empty string or a list in the form
-used internally by [sqlite-config.tcl][]'s `sqlite-configure`.
-
-Next, define:
-
->
-```
-proc sqlite-custom-handle-flags {} {
-  ... do any custom flag handling here ...
-}
-```
-
-That function, if defined, will be called relatively late in the
-configure process, before any filtered files are generated but after
-all other significant processing.
-
-
-[Autosetup]: https://msteveb.github.io/autosetup/
-[auto.def]: /file/auto.def
-[autoconf/auto.def]: /file/autoconf/auto.def
-[autosetup-git]: https://github.com/msteveb/autosetup
-[proj.tcl]: /file/autosetup/proj.tcl
-[sqlite-config.tcl]: /file/autosetup/sqlite-config.tcl
-[Makefile.in]: /file/Makefile.in
-[main.mk]: /file/main.mk
-[JimTCL]: https://msteveb.github.io/jimtcl/
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup
deleted file mode 100644
index c3a31be..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup
+++ /dev/null
@@ -1,2544 +0,0 @@
-#!/bin/sh
-# Copyright (c) 2006-2011 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-# vim:se syntax=tcl:
-# \
-dir=`dirname "$0"`; exec "`$dir/autosetup-find-tclsh`" "$0" "$@"
-
-# Note that the version has a trailing + on unreleased versions
-set autosetup(version) 0.7.2
-
-# Can be set to 1 to debug early-init problems
-set autosetup(debug) [expr {"--autosetup-debug" in $argv}]
-
-##################################################################
-#
-# Main flow of control, option handling
-#
-proc main {argv} {
-	global autosetup define
-
-	# There are 3 potential directories involved:
-	# 1. The directory containing autosetup (this script)
-	# 2. The directory containing auto.def
-	# 3. The current directory
-
-	# From this we need to determine:
-	# a. The path to this script (and related support files)
-	# b. The path to auto.def
-	# c. The build directory, where output files are created
-
-	# This is also complicated by the fact that autosetup may
-	# have been run via the configure wrapper ([getenv WRAPPER] is set)
-
-	# Here are the rules.
-	# a. This script is $::argv0
-	#    => dir, prog, exe, libdir
-	# b. auto.def is in the directory containing the configure wrapper,
-	#    otherwise it is in the current directory.
-	#    => srcdir, autodef
-	# c. The build directory is the current directory
-	#    => builddir, [pwd]
-
-	# 'misc' is needed before we can do anything, so set a temporary libdir
-	# in case this is the development version
-	set autosetup(libdir) [file dirname $::argv0]/lib
-	use misc
-
-	# (a)
-	set autosetup(dir) [realdir [file dirname [realpath $::argv0]]]
-	set autosetup(prog) [file join $autosetup(dir) [file tail $::argv0]]
-	set autosetup(exe) [getenv WRAPPER $autosetup(prog)]
-	if {$autosetup(installed)} {
-		set autosetup(libdir) $autosetup(dir)
-	} else {
-		set autosetup(libdir) [file join $autosetup(dir) lib]
-	}
-	autosetup_add_dep $autosetup(prog)
-
-	# (b)
-	if {[getenv WRAPPER ""] eq ""} {
-		# Invoked directly
-		set autosetup(srcdir) [pwd]
-	} else {
-		# Invoked via the configure wrapper
-		set autosetup(srcdir) [file-normalize [file dirname $autosetup(exe)]]
-	}
-	set autosetup(autodef) [relative-path $autosetup(srcdir)/auto.def]
-
-	# (c)
-	set autosetup(builddir) [pwd]
-
-	set autosetup(argv) $argv
-	set autosetup(cmdline) {}
-	# options is a list of known options
-	set autosetup(options) {}
-	# optset is a dictionary of option values set by the user based on getopt
-	set autosetup(optset) {}
-	# optdefault is a dictionary of default values
-	set autosetup(optdefault) {}
-	# options-defaults is a dictionary of overrides for default values for options
-	set autosetup(options-defaults) {}
-	set autosetup(optionhelp) {}
-	set autosetup(showhelp) 0
-
-	use util
-
-	# Parse options
-	use getopt
-
-	# At the is point we don't know what is a valid option
-	# We simply parse anything that looks like an option
-	set autosetup(getopt) [getopt argv]
-
-	#"=Core Options:"
-	options-add {
-		help:=all       => "display help and options. Optional: module name, such as --help=system"
-		licence license => "display the autosetup license"
-		version         => "display the version of autosetup"
-		ref:=text manual:=text
-		reference:=text => "display the autosetup command reference. 'text', 'wiki', 'asciidoc' or 'markdown'"
-		autosetup-debug => "display debugging output as autosetup runs"
-		install:=.      => "install autosetup to the current or given directory"
-	}
-	if {$autosetup(installed)} {
-		# hidden options so we can produce a nice error
-		options-add {
-			sysinstall:path
-		}
-	} else {
-		options-add {
-			sysinstall:path  => "install standalone autosetup to the given directory (e.g.: /usr/local)"
-		}
-	}
-	options-add {
-		force init:=help   => "create initial auto.def, etc.  Use --init=help for known types"
-		# Undocumented options
-		option-checking=1
-		nopager
-		quiet
-		timing
-		conf:
-	}
-
-	if {[opt-bool version]} {
-		puts $autosetup(version)
-		exit 0
-	}
-
-	# autosetup --conf=alternate-auto.def
-	if {[opt-str conf o]} {
-		set autosetup(autodef) $o
-	}
-
-	# Debugging output (set this early)
-	incr autosetup(debug) [opt-bool autosetup-debug]
-	incr autosetup(force) [opt-bool force]
-	incr autosetup(msg-quiet) [opt-bool quiet]
-	incr autosetup(msg-timing) [opt-bool timing]
-
-	# If the local module exists, source it now to allow for
-	# project-local customisations
-	if {[file exists $autosetup(libdir)/local.tcl]} {
-		use local
-	}
-
-	# Now any auto-load modules
-	autosetup_load_auto_modules
-
-	if {[opt-str help o]} {
-		incr autosetup(showhelp)
-		use help
-		autosetup_help $o
-	}
-
-	if {[opt-bool licence license]} {
-		use help
-		autosetup_show_license
-		exit 0
-	}
-
-	if {[opt-str {manual ref reference} o]} {
-		use help
-		autosetup_reference $o
-	}
-
-	# Allow combining --install and --init
-	set earlyexit 0
-	if {[opt-str install o]} {
-		use install
-		autosetup_install $o
-		incr earlyexit
-	}
-
-	if {[opt-str init o]} {
-		use init
-		autosetup_init $o
-		incr earlyexit
-	}
-
-	if {$earlyexit} {
-		exit 0
-	}
-	if {[opt-str sysinstall o]} {
-		use install
-		autosetup_install $o 1
-		exit 0
-	}
-
-	if {![file exists $autosetup(autodef)]} {
-		# Check for invalid option first
-		options {}
-		user-error "No auto.def found in \"$autosetup(srcdir)\" (use [file tail $::autosetup(exe)] --init to create one)"
-	}
-
-	# Parse extra arguments into autosetup(cmdline)
-	foreach arg $argv {
-		if {[regexp {([^=]*)=(.*)} $arg -> n v]} {
-			dict set autosetup(cmdline) $n $v
-			define $n $v
-		} else {
-			user-error "Unexpected parameter: $arg"
-		}
-	}
-
-	autosetup_add_dep $autosetup(autodef)
-
-	# Add $argv to CONFIGURE_OPTS
-	define-append-argv CONFIGURE_OPTS {*}$autosetup(argv)
-	# Set up AUTOREMAKE to reconfigure with the same args
-	define-append-argv AUTOREMAKE {*}$autosetup(exe) {*}$autosetup(argv)
-
-	# Log how we were invoked
-	configlog "Invoked as: [getenv WRAPPER $::argv0] [quote-argv $autosetup(argv)]"
-	configlog "Tclsh: [info nameofexecutable]"
-
-	# Load auto.def as module "auto.def"
-	autosetup_load_module auto.def source $autosetup(autodef)
-
-	# Could warn here if options {} was not specified
-
-	show-notices
-
-	if {$autosetup(debug)} {
-		msg-result "Writing all defines to config.log"
-		configlog "================ defines ======================"
-		foreach n [lsort [array names define]] {
-			configlog "define $n $define($n)"
-		}
-	}
-
-	exit 0
-}
-
-# @section Option Handling
-
-# @opt-bool ?-nodefault? option ...
-#
-# Check each of the named, boolean options and if any have been explicitly enabled
-# or disabled by the user, return 1 or 0 accordingly.
-#
-# If the option was specified more than once, the last value wins.
-# e.g. With '--enable-foo --disable-foo', '[opt-bool foo]' will return 0
-#
-# If no value was specified by the user, returns the default value for the
-# first option. If '-nodefault' is given, this behaviour changes and
-# -1 is returned instead.
-#
-proc opt-bool {args} {
-	set nodefault 0
-	if {[lindex $args 0] eq "-nodefault"} {
-		set nodefault 1
-		set args [lrange $args 1 end]
-	}
-	option-check-names {*}$args
-
-	foreach opt $args {
-		if {[dict exists $::autosetup(optset) $opt]} {
-			return [dict get $::autosetup(optset) $opt]
-		}
-	}
-
-	if {$nodefault} {
-		return -1
-	}
-	# Default value is the default for the first option
-	return [dict get $::autosetup(optdefault) [lindex $args 0]]
-}
-
-# @opt-val optionlist ?default=""?
-#
-# Returns a list containing all the values given for the non-boolean options in '$optionlist'.
-# There will be one entry in the list for each option given by the user, including if the
-# same option was used multiple times.
-#
-# If no options were set, '$default' is returned (exactly, not as a list).
-#
-# Note: For most use cases, 'opt-str' should be preferred.
-#
-proc opt-val {names {default ""}} {
-	option-check-names {*}$names
-
-	foreach opt $names {
-		if {[dict exists $::autosetup(optset) $opt]} {
-			lappend result {*}[dict get $::autosetup(optset) $opt]
-		}
-	}
-	if {[info exists result]} {
-		return $result
-	}
-	return $default
-}
-
-# @opt-str optionlist varname ?default?
-#
-# Sets '$varname' in the callers scope to the value for one of the given options.
-#
-# For the list of options given in '$optionlist', if any value is set for any option,
-# the option value is taken to be the *last* value of the last option (in the order given).
-#
-# If no option was given, and a default was specified with 'options-defaults',
-# that value is used.
-#
-# If no 'options-defaults' value was given and '$default' was given, it is used.
-#
-# If none of the above provided a value, no value is set.
-#
-# The return value depends on whether '$default' was specified.
-# If it was, the option value is returned.
-# If it was not, 1 is returns if a value was set, or 0 if not.
-#
-# Typical usage is as follows:
-#
-## if {[opt-str {myopt altname} o]} {
-##     do something with $o
-## }
-#
-# Or:
-## define myname [opt-str {myopt altname} o "/usr/local"]
-#
-proc opt-str {names varname args} {
-	global autosetup
-
-	option-check-names {*}$names
-	upvar $varname value
-
-	if {[llength $args]} {
-		# A default was given, so always return the string value of the option
-		set default [lindex $args 0]
-		set retopt 1
-	} else {
-		# No default, so return 0 or 1 to indicate if a value was found
-		set retopt 0
-	}
-
-	foreach opt $names {
-		if {[dict exists $::autosetup(optset) $opt]} {
-			set result [lindex [dict get $::autosetup(optset) $opt] end]
-		}
-	}
-
-	if {![info exists result]} {
-		# No user-specified value. Has options-defaults been set?
-		foreach opt $names {
-			if {[dict exists $::autosetup(optdefault) $opt]} {
-				set result [dict get $autosetup(optdefault) $opt]
-			}
-		}
-	}
-
-	if {[info exists result]} {
-		set value $result
-		if {$retopt} {
-			return $value
-		}
-		return 1
-	}
-
-	if {$retopt} {
-		set value $default
-		return $value
-	}
-
-	return 0
-}
-
-proc option-check-names {args} {
-	foreach o $args {
-		if {$o ni $::autosetup(options)} {
-			autosetup-error "Request for undeclared option --$o"
-		}
-	}
-}
-
-# Parse the option definition in $opts and update
-# ::autosetup(setoptions) and ::autosetup(optionhelp) appropriately
-#
-proc options-add {opts} {
-	global autosetup
-
-	# First weed out comment lines
-	set realopts {}
-	foreach line [split $opts \n] {
-		if {![string match "#*" [string trimleft $line]]} {
-			append realopts $line \n
-		}
-	}
-	set opts $realopts
-
-	for {set i 0} {$i < [llength $opts]} {incr i} {
-		set opt [lindex $opts $i]
-		if {[string match =* $opt]} {
-			# This is a special heading
-			lappend autosetup(optionhelp) [list $opt $autosetup(module)]
-			continue
-		}
-		unset -nocomplain defaultvalue equal value
-
-		#puts "i=$i, opt=$opt"
-		regexp {^([^:=]*)(:)?(=)?(.*)$} $opt -> name colon equal value
-		if {$name in $autosetup(options)} {
-			autosetup-error "Option $name already specified"
-		}
-
-		#puts "$opt => $name $colon $equal $value"
-
-		# Find the corresponding value in the user options
-		# and set the default if necessary
-		if {[string match "-*" $opt]} {
-			# We no longer support documentation-only options, like "-C <dir>"
-			autosetup-error "Option $opt is not supported"
-		} elseif {$colon eq ""} {
-			# Boolean option
-			lappend autosetup(options) $name
-
-			# Check for override
-			if {[dict exists $autosetup(options-defaults) $name]} {
-				# A default was specified with options-defaults, so use it
-				set value [dict get $autosetup(options-defaults) $name]
-			}
-
-			if {$value eq "1"} {
-				set opthelp "--disable-$name"
-			} else {
-				set opthelp "--$name"
-			}
-
-			# Set the default
-			if {$value eq ""} {
-				set value 0
-			}
-			set defaultvalue $value
-			dict set autosetup(optdefault) $name $defaultvalue
-
-			if {[dict exists $autosetup(getopt) $name]} {
-				# The option was specified by the user. Look at the last value.
-				lassign [lindex [dict get $autosetup(getopt) $name] end] type setvalue
-				if {$type eq "str"} {
-					# Can we convert the value to a boolean?
-					if {$setvalue in {1 enabled yes}} {
-						set setvalue 1
-					} elseif {$setvalue in {0 disabled no}} {
-						set setvalue 0
-					} else {
-						user-error "Boolean option $name given as --$name=$setvalue"
-					}
-				}
-				dict set autosetup(optset) $name $setvalue
-				#puts "Found boolean option --$name=$setvalue"
-			}
-		} else {
-			# String option.
-			lappend autosetup(options) $name
-
-			if {$equal ne "="} {
-				# Was the option given as "name:value=default"?
-				# If so, set $value to the display name and $defaultvalue to the default
-				# (This is the preferred way to set a default value for a string option)
-				if {[regexp {^([^=]+)=(.*)$} $value -> value defaultvalue]} {
-					dict set autosetup(optdefault) $name $defaultvalue
-				}
-			}
-
-			# Maybe override the default value
-			if {[dict exists $autosetup(options-defaults) $name]} {
-				# A default was specified with options-defaults, so use it
-				set defaultvalue [dict get $autosetup(options-defaults) $name]
-				dict set autosetup(optdefault) $name $defaultvalue
-			} elseif {![info exists defaultvalue]} {
-				# No default value was given by value=default or options-defaults
-				# so use the value as the default when the plain option with no
-				# value is given (.e.g. just --opt instead of --opt=value)
-				set defaultvalue $value
-			}
-
-			if {$equal eq "="} {
-				# String option with optional value
-				set opthelp "--$name?=$value?"
-			} else {
-				# String option with required value
-				set opthelp "--$name=$value"
-			}
-
-			# Get the values specified by the user
-			if {[dict exists $autosetup(getopt) $name]} {
-				set listvalue {}
-
-				foreach pair [dict get $autosetup(getopt) $name] {
-					lassign $pair type setvalue
-					if {$type eq "bool" && $setvalue} {
-						if {$equal ne "="} {
-							user-error "Option --$name requires a value"
-						}
-						# If given as a boolean, use the default value
-						set setvalue $defaultvalue
-					}
-					lappend listvalue $setvalue
-				}
-
-				#puts "Found string option --$name=$listvalue"
-				dict set autosetup(optset) $name $listvalue
-			}
-		}
-
-		# Now create the help for this option if appropriate
-		if {[lindex $opts $i+1] eq "=>"} {
-			set desc [lindex $opts $i+2]
-			if {[info exists defaultvalue]} {
-				set desc [string map [list @default@ $defaultvalue] $desc]
-			}
-			# A multi-line description
-			lappend autosetup(optionhelp) [list $opthelp $autosetup(module) $desc]
-			incr i 2
-		}
-	}
-}
-
-# @module-options optionlist
-#
-# Deprecated. Simply use 'options' from within a module.
-proc module-options {opts} {
-	options $opts
-}
-
-proc max {a b} {
-	expr {$a > $b ? $a : $b}
-}
-
-proc options-wrap-desc {text length firstprefix nextprefix initial} {
-	set len $initial
-	set space $firstprefix
-	foreach word [split $text] {
-		set word [string trim $word]
-		if {$word == ""} {
-			continue
-		}
-		if {$len && [string length $space$word] + $len >= $length} {
-			puts ""
-			set len 0
-			set space $nextprefix
-		}
-		incr len [string length $space$word]
-		puts -nonewline $space$word
-		set space " "
-	}
-	if {$len} {
-		puts ""
-	}
-}
-
-# Display options (from $autosetup(optionhelp)) for modules that match
-# glob pattern $what
-proc options-show {what} {
-	set local 0
-	# Determine the max option width
-	set max 0
-	foreach help $::autosetup(optionhelp) {
-		lassign $help opt module desc
-		if {![string match $what $module]} {
-			continue
-		}
-		if {[string match =* $opt] || [string match \n* $desc]} {
-			continue
-		}
-		set max [max $max [string length $opt]]
-	}
-	set indent [string repeat " " [expr {$max+4}]]
-	set cols [getenv COLUMNS 80]
-	catch {
-		lassign [exec stty size] _ sttycols
-		if {[string is integer -strict $sttycols]} {
-			set cols $sttycols
-		}
-	}
-	incr cols -1
-	# Now output
-	foreach help $::autosetup(optionhelp) {
-		lassign $help opt module desc
-		if {![string match $what $module]} {
-			continue
-		}
-		if {$local == 0 && $module eq "auto.def"} {
-			puts "Local Options:"
-			incr local
-		}
-		if {[string match =* $opt]} {
-			# Output a special heading line"
-			puts [string range $opt 1 end]
-			continue
-		}
-		puts -nonewline "  [format %-${max}s $opt]"
-		if {[string match \n* $desc]} {
-			# Output a pre-formatted help description as-is
-			puts $desc
-		} else {
-			options-wrap-desc [string trim $desc] $cols "  " $indent [expr {$max+2}]
-		}
-	}
-}
-
-# @options optionspec
-#
-# Specifies configuration-time options which may be selected by the user
-# and checked with 'opt-str' and 'opt-bool'. '$optionspec' contains a series
-# of options specifications separated by newlines, as follows:
-#
-# A boolean option is of the form:
-#
-## name[=0|1]  => "Description of this boolean option"
-#
-# The default is 'name=0', meaning that the option is disabled by default.
-# If 'name=1' is used to make the option enabled by default, the description should reflect
-# that with text like "Disable support for ...".
-#
-# An argument option (one which takes a parameter) is of one of the following forms:
-#
-## name:value         => "Description of this option"
-## name:value=default => "Description of this option with a default value"
-## name:=value        => "Description of this option with an optional value"
-#
-# If the 'name:value' form is used, the value must be provided with the option (as '--name=myvalue').
-# If the 'name:value=default' form is used, the option has the given default value even if not
-# specified by the user.
-# If the 'name:=value' form is used, the value is optional and the given value is used
-# if it is not provided.
-#
-# The description may contain '@default@', in which case it will be replaced with the default
-# value for the option (taking into account defaults specified with 'options-defaults'.
-#
-# Undocumented options are also supported by omitting the '=> description'.
-# These options are not displayed with '--help' and can be useful for internal options or as aliases.
-#
-# For example, '--disable-lfs' is an alias for '--disable=largefile':
-#
-## lfs=1 largefile=1 => "Disable large file support"
-#
-proc options {optlist} {
-	global autosetup
-
-	options-add $optlist
-
-	if {$autosetup(showhelp)} {
-		# If --help, stop now to show help
-		return -code break
-	}
-
-	if {$autosetup(module) eq "auto.def"} {
-		# Check for invalid options
-		if {[opt-bool option-checking]} {
-			foreach o [dict keys $::autosetup(getopt)] {
-				if {$o ni $::autosetup(options)} {
-					user-error "Unknown option --$o"
-				}
-			}
-		}
-	}
-}
-
-# @options-defaults dictionary
-#
-# Specifies a dictionary of options and a new default value for each of those options.
-# Use before any 'use' statements in 'auto.def' to change the defaults for
-# subsequently included modules.
-proc options-defaults {dict} {
-	foreach {n v} $dict {
-		dict set ::autosetup(options-defaults) $n $v
-	}
-}
-
-proc config_guess {} {
-	if {[file-isexec $::autosetup(dir)/autosetup-config.guess]} {
-		if {[catch {exec-with-stderr sh $::autosetup(dir)/autosetup-config.guess} alias]} {
-			user-error $alias
-		}
-		return $alias
-	} else {
-		configlog "No autosetup-config.guess, so using uname"
-		string tolower [exec uname -p]-unknown-[exec uname -s][exec uname -r]
-	}
-}
-
-proc config_sub {alias} {
-	if {[file-isexec $::autosetup(dir)/autosetup-config.sub]} {
-		if {[catch {exec-with-stderr sh $::autosetup(dir)/autosetup-config.sub $alias} alias]} {
-			user-error $alias
-		}
-	}
-	return $alias
-}
-
-# @section Variable Definitions (defines)
-
-# @define name ?value=1?
-#
-# Defines the named variable to the given value.
-# These (name, value) pairs represent the results of the configuration check
-# and are available to be subsequently checked, modified and substituted.
-#
-proc define {name {value 1}} {
-	set ::define($name) $value
-	#dputs "$name <= $value"
-}
-
-# @define-push {name ...} script
-#
-# Save the values of the given defines, evaluation the script, then restore.
-# For example, to avoid updating AS_FLAGS and AS_CXXFLAGS:
-## define-push {AS_CFLAGS AS_CXXFLAGS} {
-##   cc-check-flags -Wno-error
-## }
-proc define-push {names script} {
-	array set unset {}
-	foreach name $names {
-		if {[is-defined $name]} {
-			set save($name) [get-define $name]
-		} else {
-			set unset($name) 1
-		}
-	}
-	uplevel 1 $script
-	array set ::define [array get save]
-	foreach name [array names unset] {
-		unset -nocomplain ::define($name)
-	}
-}
-
-# @undefine name
-#
-# Undefine the named variable.
-#
-proc undefine {name} {
-	unset -nocomplain ::define($name)
-	#dputs "$name <= <undef>"
-}
-
-# @define-append name value ...
-#
-# Appends the given value(s) to the given "defined" variable.
-# If the variable is not defined or empty, it is set to '$value'.
-# Otherwise the value is appended, separated by a space.
-# Any extra values are similarly appended.
-#
-# Note that define-append is not designed to add values containing spaces.
-# If values may contain spaces, consider define-append-argv instead.
-#
-proc define-append {name args} {
-	if {[get-define $name ""] ne ""} {
-		foreach arg $args {
-			if {$arg eq ""} {
-				continue
-			}
-			append ::define($name) " " $arg
-		}
-	} else {
-		set ::define($name) [join $args]
-	}
-	#dputs "$name += [join $args] => $::define($name)"
-}
-
-# @define-append-argv name value ...
-#
-# Similar to define-append except designed to construct shell command
-# lines, including correct handling of parameters with spaces.
-#
-# Each non-empty value is quoted if necessary and then appended to the given variable
-# if it does not already exist.
-#
-proc define-append-argv {name args} {
-	set seen {}
-	set new {}
-	foreach val [list {*}[get-define $name ""] {*}$args] {
-		if {$val ne {} && ![dict exists $seen $val]} {
-			lappend new [quote-if-needed $val]
-			dict set seen $val 1
-		}
-	}
-	set ::define($name) [join $new " "]
-	#dputs "$name += [join $args] => $::define($name)"
-}
-
-# @get-define name ?default=0?
-#
-# Returns the current value of the "defined" variable, or '$default'
-# if not set.
-#
-proc get-define {name {default 0}} {
-	if {[info exists ::define($name)]} {
-		#dputs "$name => $::define($name)"
-		return $::define($name)
-	}
-	#dputs "$name => $default"
-	return $default
-}
-
-# @is-defined name
-#
-# Returns 1 if the given variable is defined.
-#
-proc is-defined {name} {
-	info exists ::define($name)
-}
-
-# @is-define-set name
-#
-# Returns 1 if the given variable is defined and is set
-# to a value other than "" or 0
-#
-proc is-define-set {name} {
-	if {[get-define $name] in {0 ""}} {
-		return 0
-	}
-	return 1
-}
-
-# @all-defines
-#
-# Returns a dictionary (name, value list) of all defined variables.
-#
-# This is suitable for use with 'dict', 'array set' or 'foreach'
-# and allows for arbitrary processing of the defined variables.
-#
-proc all-defines {} {
-	array get ::define
-}
-
-# @section Environment/Helpers
-
-# @get-env name default
-#
-# If '$name' was specified on the command line, return it.
-# Otherwise if '$name' was set in the environment, return it.
-# Otherwise return '$default'.
-#
-proc get-env {name default} {
-	if {[dict exists $::autosetup(cmdline) $name]} {
-		return [dict get $::autosetup(cmdline) $name]
-	}
-	getenv $name $default
-}
-
-# @env-is-set name
-#
-# Returns 1 if '$name' was specified on the command line or in the environment.
-# Note that an empty environment variable is not considered to be set.
-#
-proc env-is-set {name} {
-	if {[dict exists $::autosetup(cmdline) $name]} {
-		return 1
-	}
-	if {[getenv $name ""] ne ""} {
-		return 1
-	}
-	return 0
-}
-
-# @readfile filename ?default=""?
-#
-# Return the contents of the file, without the trailing newline.
-# If the file doesn't exist or can't be read, returns '$default'.
-#
-proc readfile {filename {default_value ""}} {
-	set result $default_value
-	catch {
-		set f [open $filename]
-		set result [read -nonewline $f]
-		close $f
-	}
-	return $result
-}
-
-# @writefile filename value
-#
-# Creates the given file containing '$value'.
-# Does not add an extra newline.
-#
-proc writefile {filename value} {
-	set f [open $filename w]
-	puts -nonewline $f $value
-	close $f
-}
-
-proc quote-if-needed {str} {
-	if {[string match {*[\" ]*} $str]} {
-		return \"[string map [list \" \\" \\ \\\\] $str]\"
-	}
-	return $str
-}
-
-proc quote-argv {argv} {
-	set args {}
-	foreach arg $argv {
-		lappend args [quote-if-needed $arg]
-	}
-	join $args
-}
-
-# @list-non-empty list
-#
-# Returns a copy of the given list with empty elements removed
-proc list-non-empty {list} {
-	set result {}
-	foreach p $list {
-		if {$p ne ""} {
-			lappend result $p
-		}
-	}
-	return $result
-}
-
-# @section Paths, Searching
-
-# @find-executable-path name
-#
-# Searches the path for an executable with the given name.
-# Note that the name may include some parameters, e.g. 'cc -mbig-endian',
-# in which case the parameters are ignored.
-# Returns the full path to the executable if found, or "" if not found.
-#
-proc find-executable-path {name} {
-	# Ignore any parameters
-	set name [lindex $name 0]
-	# The empty string is never a valid executable
-	if {$name ne ""} {
-		foreach p [split-path] {
-			dputs "Looking for $name in $p"
-			set exec [file join $p $name]
-			if {[file-isexec $exec]} {
-				dputs "Found $name -> $exec"
-				return $exec
-			}
-		}
-	}
-	return {}
-}
-
-# @find-executable name
-#
-# Searches the path for an executable with the given name.
-# Note that the name may include some parameters, e.g. 'cc -mbig-endian',
-# in which case the parameters are ignored.
-# Returns 1 if found, or 0 if not.
-#
-proc find-executable {name} {
-	if {[find-executable-path $name] eq {}} {
-		return 0
-	}
-	return 1
-}
-
-# @find-an-executable ?-required? name ...
-#
-# Given a list of possible executable names,
-# searches for one of these on the path.
-#
-# Returns the name found, or "" if none found.
-# If the first parameter is '-required', an error is generated
-# if no executable is found.
-#
-proc find-an-executable {args} {
-	set required 0
-	if {[lindex $args 0] eq "-required"} {
-		set args [lrange $args 1 end]
-		incr required
-	}
-	foreach name $args {
-		if {[find-executable $name]} {
-			return $name
-		}
-	}
-	if {$required} {
-		if {[llength $args] == 1} {
-			user-error "failed to find: [join $args]"
-		} else {
-			user-error "failed to find one of: [join $args]"
-		}
-	}
-	return ""
-}
-
-# @section Logging, Messages and Errors
-
-# @configlog msg
-#
-# Writes the given message to the configuration log, 'config.log'.
-#
-proc configlog {msg} {
-	if {![info exists ::autosetup(logfh)]} {
-		set ::autosetup(logfh) [open config.log w]
-	}
-	puts $::autosetup(logfh) $msg
-}
-
-# @msg-checking msg
-#
-# Writes the message with no newline to stdout.
-#
-proc msg-checking {msg} {
-	if {$::autosetup(msg-quiet) == 0} {
-		maybe-show-timestamp
-		puts -nonewline $msg
-		set ::autosetup(msg-checking) 1
-	}
-}
-
-# @msg-result msg
-#
-# Writes the message to stdout.
-#
-proc msg-result {msg} {
-	if {$::autosetup(msg-quiet) == 0} {
-		maybe-show-timestamp
-		puts $msg
-		set ::autosetup(msg-checking) 0
-		show-notices
-	}
-}
-
-# @msg-quiet command ...
-#
-# 'msg-quiet' evaluates it's arguments as a command with output
-# from 'msg-checking' and 'msg-result' suppressed.
-#
-# This is useful if a check needs to run a subcheck which isn't
-# of interest to the user.
-proc msg-quiet {args} {
-	incr ::autosetup(msg-quiet)
-	set rc [uplevel 1 $args]
-	incr ::autosetup(msg-quiet) -1
-	return $rc
-}
-
-# Will be overridden by 'use misc'
-proc error-stacktrace {msg} {
-	return $msg
-}
-
-proc error-location {msg} {
-	return $msg
-}
-
-##################################################################
-#
-# Debugging output
-#
-proc dputs {msg} {
-	if {$::autosetup(debug)} {
-		puts $msg
-	}
-}
-
-##################################################################
-#
-# User and system warnings and errors
-#
-# Usage errors such as wrong command line options
-
-# @user-error msg
-#
-# Indicate incorrect usage to the user, including if required components
-# or features are not found.
-# 'autosetup' exits with a non-zero return code.
-#
-proc user-error {msg} {
-	show-notices
-	puts stderr "Error: $msg"
-	puts stderr "Try: '[file tail $::autosetup(exe)] --help' for options"
-	exit 1
-}
-
-# @user-notice msg
-#
-# Output the given message to stderr.
-#
-proc user-notice {msg} {
-	lappend ::autosetup(notices) $msg
-}
-
-# Incorrect usage in the auto.def file. Identify the location.
-proc autosetup-error {msg} {
-	autosetup-full-error [error-location $msg]
-}
-
-# Like autosetup-error, except $msg is the full error message.
-proc autosetup-full-error {msg} {
-	show-notices
-	puts stderr $msg
-	exit 1
-}
-
-proc show-notices {} {
-	if {$::autosetup(msg-checking)} {
-		puts ""
-		set ::autosetup(msg-checking) 0
-	}
-	flush stdout
-	if {[info exists ::autosetup(notices)]} {
-		puts stderr [join $::autosetup(notices) \n]
-		unset ::autosetup(notices)
-	}
-}
-
-proc maybe-show-timestamp {} {
-	if {$::autosetup(msg-timing) && $::autosetup(msg-checking) == 0} {
-		puts -nonewline [format {[%6.2f] } [expr {([clock millis] - $::autosetup(start)) % 10000 / 1000.0}]]
-	}
-}
-
-# @autosetup-require-version required
-#
-# Checks the current version of 'autosetup' against '$required'.
-# A fatal error is generated if the current version is less than that required.
-#
-proc autosetup-require-version {required} {
-	if {[compare-versions $::autosetup(version) $required] < 0} {
-		user-error "autosetup version $required is required, but this is $::autosetup(version)"
-	}
-}
-
-proc autosetup_version {} {
-	return "autosetup v$::autosetup(version)"
-}
-
-##################################################################
-#
-# Directory/path handling
-#
-
-proc realdir {dir} {
-	set oldpwd [pwd]
-	cd $dir
-	set pwd [pwd]
-	cd $oldpwd
-	return $pwd
-}
-
-# Follow symlinks until we get to something which is not a symlink
-proc realpath {path} {
-	while {1} {
-		if {[catch {
-			set path [file readlink $path]
-		}]} {
-			# Not a link
-			break
-		}
-	}
-	return $path
-}
-
-# Convert absolute path, $path into a path relative
-# to the given directory (or the current dir, if not given).
-#
-proc relative-path {path {pwd {}}} {
-	set diff 0
-	set same 0
-	set newf {}
-	set prefix {}
-	set path [file-normalize $path]
-	if {$pwd eq ""} {
-		set pwd [pwd]
-	} else {
-		set pwd [file-normalize $pwd]
-	}
-
-	if {$path eq $pwd} {
-		return .
-	}
-
-	# Try to make the filename relative to the current dir
-	foreach p [split $pwd /] f [split $path /] {
-		if {$p ne $f} {
-			incr diff
-		} elseif {!$diff} {
-			incr same
-		}
-		if {$diff} {
-			if {$p ne ""} {
-				# Add .. for sibling or parent dir
-				lappend prefix ..
-			}
-			if {$f ne ""} {
-				lappend newf $f
-			}
-		}
-	}
-	if {$same == 1 || [llength $prefix] > 3} {
-		return $path
-	}
-
-	file join [join $prefix /] [join $newf /]
-}
-
-# Add filename as a dependency to rerun autosetup
-# The name will be normalised (converted to a full path)
-#
-proc autosetup_add_dep {filename} {
-	lappend ::autosetup(deps) [file-normalize $filename]
-}
-
-# @section Modules Support
-
-##################################################################
-#
-# Library module support
-#
-
-# @use module ...
-#
-# Load the given library modules.
-# e.g. 'use cc cc-shared'
-#
-# Note that module 'X' is implemented in either 'autosetup/X.tcl'
-# or 'autosetup/X/init.tcl'
-#
-# The latter form is useful for a complex module which requires additional
-# support file. In this form, '$::usedir' is set to the module directory
-# when it is loaded.
-#
-proc use {args} {
-	global autosetup libmodule modsource
-
-	set dirs [list $autosetup(libdir)]
-	if {[info exists autosetup(srcdir)]} {
-		lappend dirs $autosetup(srcdir)/autosetup
-	}
-	foreach m $args {
-		if {[info exists libmodule($m)]} {
-			continue
-		}
-		set libmodule($m) 1
-
-		if {[info exists modsource(${m}.tcl)]} {
-			autosetup_load_module $m eval $modsource(${m}.tcl)
-		} else {
-			set locs [list ${m}.tcl ${m}/init.tcl]
-			set found 0
-			foreach dir $dirs {
-				foreach loc $locs {
-					set source $dir/$loc
-					if {[file exists $source]} {
-						incr found
-						break
-					}
-				}
-				if {$found} {
-					break
-				}
-			}
-			if {$found} {
-				# For the convenience of the "use" source, point to the directory
-				# it is being loaded from
-				set ::usedir [file dirname $source]
-				autosetup_load_module $m source $source
-				autosetup_add_dep $source
-			} else {
-				autosetup-error "use: No such module: $m"
-			}
-		}
-	}
-}
-
-proc autosetup_load_auto_modules {} {
-	global autosetup modsource
-	# First load any embedded auto modules
-	foreach mod [array names modsource *.auto] {
-		autosetup_load_module $mod eval $modsource($mod)
-	}
-	# Now any external auto modules
-	foreach file [glob -nocomplain $autosetup(libdir)/*.auto $autosetup(libdir)/*/*.auto] {
-		autosetup_load_module [file tail $file] source $file
-	}
-}
-
-# Load module source in the global scope by executing the given command
-proc autosetup_load_module {module args} {
-	global autosetup
-	set prev $autosetup(module)
-	set autosetup(module) $module
-
-	if {[catch [list uplevel #0 $args] msg opts] ni {0 2 3}} {
-		autosetup-full-error [error-dump $msg $opts $::autosetup(debug)]
-	}
-	set autosetup(module) $prev
-}
-
-# Initial settings
-set autosetup(exe) $::argv0
-set autosetup(istcl) 1
-set autosetup(start) [clock millis]
-set autosetup(installed) 0
-set autosetup(sysinstall) 0
-set autosetup(msg-checking) 0
-set autosetup(msg-quiet) 0
-set autosetup(inittypes) {}
-set autosetup(module) autosetup
-
-# Embedded modules are inserted below here
-set autosetup(installed) 1
-set autosetup(sysinstall) 0
-# ----- @module asciidoc-formatting.tcl -----
-
-set modsource(asciidoc-formatting.tcl) {
-# Copyright (c) 2010 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# Module which provides text formatting
-# asciidoc format
-
-use formatting
-
-proc para {text} {
-    regsub -all "\[ \t\n\]+" [string trim $text] " "
-}
-proc title {text} {
-    underline [para $text] =
-    nl
-}
-proc p {text} {
-    puts [para $text]
-    nl
-}
-proc code {text} {
-    foreach line [parse_code_block $text] {
-        puts "    $line"
-    }
-    nl
-}
-proc codelines {lines} {
-    foreach line $lines {
-        puts "    $line"
-    }
-    nl
-}
-proc nl {} {
-    puts ""
-}
-proc underline {text char} {
-    regexp "^(\[ \t\]*)(.*)" $text -> indent words
-    puts $text
-    puts $indent[string repeat $char [string length $words]]
-}
-proc section {text} {
-    underline "[para $text]" -
-    nl
-}
-proc subsection {text} {
-    underline "$text" ~
-    nl
-}
-proc bullet {text} {
-    puts "* [para $text]"
-}
-proc indent {text} {
-    puts " :: "
-    puts [para $text]
-}
-proc defn {first args} {
-    set sep ""
-    if {$first ne ""} {
-        puts "${first}::"
-    } else {
-        puts " :: "
-    }
-    set defn [string trim [join $args \n]]
-    regsub -all "\n\n" $defn "\n ::\n" defn
-    puts $defn
-}
-}
-
-# ----- @module formatting.tcl -----
-
-set modsource(formatting.tcl) {
-# Copyright (c) 2010 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# Module which provides common text formatting
-
-# This is designed for documentation which looks like:
-# code {...}
-# or
-# code {
-#    ...
-#    ...
-# }
-# In the second case, we need to work out the indenting
-# and strip it from all lines but preserve the remaining indenting.
-# Note that all lines need to be indented with the same initial
-# spaces/tabs.
-#
-# Returns a list of lines with the indenting removed.
-#
-proc parse_code_block {text} {
-    # If the text begins with newline, take the following text,
-    # otherwise just return the original
-    if {![regexp "^\n(.*)" $text -> text]} {
-        return [list [string trim $text]]
-    }
-
-    # And trip spaces off the end
-    set text [string trimright $text]
-
-    set min 100
-    # Examine each line to determine the minimum indent
-    foreach line [split $text \n] {
-        if {$line eq ""} {
-            # Ignore empty lines for the indent calculation
-            continue
-        }
-        regexp "^(\[ \t\]*)" $line -> indent
-        set len [string length $indent]
-        if {$len < $min} {
-            set min $len
-        }
-    }
-
-    # Now make a list of lines with this indent removed
-    set lines {}
-    foreach line [split $text \n] {
-        lappend lines [string range $line $min end]
-    }
-
-    # Return the result
-    return $lines
-}
-}
-
-# ----- @module getopt.tcl -----
-
-set modsource(getopt.tcl) {
-# Copyright (c) 2006 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# Simple getopt module
-
-# Parse everything out of the argv list which looks like an option
-# Everything which doesn't look like an option, or is after --, is left unchanged
-# Understands --enable-xxx as a synonym for --xxx to enable the boolean option xxx.
-# Understands --disable-xxx to disable the boolean option xxx.
-#
-# The returned value is a dictionary keyed by option name
-# Each value is a list of {type value} ... where type is "bool" or "str".
-# The value for a boolean option is 0 or 1. The value of a string option is the value given.
-proc getopt {argvname} {
-	upvar $argvname argv
-	set nargv {}
-
-	set opts {}
-
-	for {set i 0} {$i < [llength $argv]} {incr i} {
-		set arg [lindex $argv $i]
-
-		#dputs arg=$arg
-
-		if {$arg eq "--"} {
-			# End of options
-			incr i
-			lappend nargv {*}[lrange $argv $i end]
-			break
-		}
-
-		if {[regexp {^--([^=][^=]+)=(.*)$} $arg -> name value]} {
-			# --name=value
-			dict lappend opts $name [list str $value]
-		} elseif {[regexp {^--(enable-|disable-)?([^=]*)$} $arg -> prefix name]} {
-			if {$prefix in {enable- ""}} {
-				set value 1
-			} else {
-				set value 0
-			}
-			dict lappend opts $name [list bool $value]
-		} else {
-			lappend nargv $arg
-		}
-	}
-
-	#puts "getopt: argv=[join $argv] => [join $nargv]"
-	#array set getopt $opts
-	#parray getopt
-
-	set argv $nargv
-
-	return $opts
-}
-}
-
-# ----- @module help.tcl -----
-
-set modsource(help.tcl) {
-# Copyright (c) 2010 WorkWare Systems http://workware.net.au/
-# All rights reserved
-
-# Module which provides usage, help and the command reference
-
-proc autosetup_help {what} {
-    use_pager
-
-    puts "Usage: [file tail $::autosetup(exe)] \[options\] \[settings\]\n"
-    puts "This is [autosetup_version], a build environment \"autoconfigurator\""
-    puts "See the documentation online at https://msteveb.github.io/autosetup/\n"
-
-    if {$what in {all local}} {
-        # Need to load auto.def now
-        if {[file exists $::autosetup(autodef)]} {
-            # Load auto.def as module "auto.def"
-            autosetup_load_module auto.def source $::autosetup(autodef)
-        }
-        if {$what eq "all"} {
-            set what *
-        } else {
-            set what auto.def
-        }
-    } else {
-        use $what
-        puts "Options for module $what:"
-    }
-    options-show $what
-    exit 0
-}
-
-proc autosetup_show_license {} {
-    global modsource autosetup
-    use_pager
-
-    if {[info exists modsource(LICENSE)]} {
-        puts $modsource(LICENSE)
-        return
-    }
-    foreach dir [list $autosetup(libdir) $autosetup(srcdir)] {
-        set path [file join $dir LICENSE]
-        if {[file exists $path]} {
-            puts [readfile $path]
-            return
-        }
-    }
-    puts "LICENSE not found"
-}
-
-# If not already paged and stdout is a tty, pipe the output through the pager
-# This is done by reinvoking autosetup with --nopager added
-proc use_pager {} {
-    if {![opt-bool nopager] && [getenv PAGER ""] ne "" && [isatty? stdin] && [isatty? stdout]} {
-        if {[catch {
-            exec [info nameofexecutable] $::argv0 --nopager {*}$::argv |& {*}[getenv PAGER] >@stdout <@stdin 2>@stderr
-        } msg opts] == 1} {
-            if {[dict get $opts -errorcode] eq "NONE"} {
-                # an internal/exec error
-                puts stderr $msg
-                exit 1
-            }
-        }
-        exit 0
-    }
-}
-
-# Outputs the autosetup references in one of several formats
-proc autosetup_reference {{type text}} {
-
-    use_pager
-
-    switch -glob -- $type {
-        wiki {use wiki-formatting}
-        ascii* {use asciidoc-formatting}
-        md - markdown {use markdown-formatting}
-        default {use text-formatting}
-    }
-
-    title "[autosetup_version] -- Command Reference"
-
-    section {Introduction}
-
-    p {
-        See https://msteveb.github.io/autosetup/ for the online documentation for 'autosetup'.
-        This documentation can also be accessed locally with `autosetup --ref`.
-    }
-
-    p {
-        'autosetup' provides a number of built-in commands which
-        are documented below. These may be used from 'auto.def' to test
-        for features, define variables, create files from templates and
-        other similar actions.
-    }
-
-    automf_command_reference
-
-    exit 0
-}
-
-proc autosetup_output_block {type lines} {
-    if {[llength $lines]} {
-        switch $type {
-            section {
-                section $lines
-            }
-            subsection {
-                subsection $lines
-            }
-            code {
-                codelines $lines
-            }
-            p {
-                p [join $lines]
-            }
-            list {
-                foreach line $lines {
-                    bullet $line
-                }
-                nl
-            }
-        }
-    }
-}
-
-# Generate a command reference from inline documentation
-proc automf_command_reference {} {
-    lappend files $::autosetup(prog)
-    lappend files {*}[lsort [glob -nocomplain $::autosetup(libdir)/{*/*.tcl,*.tcl}]]
-
-    # We want to process all non-module files before module files
-    # and then modules in alphabetical order.
-    # So examine all files and extract docs into doc($modulename) and doc(_core_)
-    #
-    # Each entry is a list of {type data} where $type is one of: section, subsection, code, list, p
-    # and $data is a string for section, subsection or a list of text lines for other types.
-
-    # XXX: Should commands be in alphabetical order too? Currently they are in file order.
-
-    set doc(_core_) {}
-    lappend doc(_core_) [list section "Core Commands"]
-
-    foreach file $files {
-        set modulename [file rootname [file tail $file]]
-        set current _core_
-        set f [open $file]
-        while {![eof $f]} {
-            set line [gets $f]
-
-            if {[regexp {^#.*@section (.*)$} $line -> section]} {
-                lappend doc($current) [list section $section]
-                continue
-            }
-
-            # Find embedded module names
-            if {[regexp {^#.*@module ([^ ]*)} $line -> modulename]} {
-                continue
-            }
-
-            # Find lines starting with "# @*" and continuing through the remaining comment lines
-            if {![regexp {^# @(.*)} $line -> cmd]} {
-                continue
-            }
-
-            # Synopsis or command?
-            if {$cmd eq "synopsis:"} {
-                set current $modulename
-                lappend doc($current) [list section "Module: $modulename"]
-            } else {
-                lappend doc($current) [list subsection $cmd]
-            }
-
-            set lines {}
-            set type p
-
-            # Now the description
-            while {![eof $f]} {
-                set line [gets $f]
-
-                if {![regexp {^#(#)? ?(.*)} $line -> hash cmd]} {
-                    break
-                }
-                if {$hash eq "#"} {
-                    set t code
-                } elseif {[regexp {^- (.*)} $cmd -> cmd]} {
-                    set t list
-                } else {
-                    set t p
-                }
-
-                #puts "hash=$hash, oldhash=$oldhash, lines=[llength $lines], cmd=$cmd"
-
-                if {$t ne $type || $cmd eq ""} {
-                    # Finish the current block
-                    lappend doc($current) [list $type $lines]
-                    set lines {}
-                    set type $t
-                }
-                if {$cmd ne ""} {
-                    lappend lines $cmd
-                }
-            }
-
-            lappend doc($current) [list $type $lines]
-        }
-        close $f
-    }
-
-    # Now format and output the results
-
-    # _core_ will sort first
-    foreach module [lsort [array names doc]] {
-        foreach item $doc($module) {
-            autosetup_output_block {*}$item
-        }
-    }
-}
-}
-
-# ----- @module init.tcl -----
-
-set modsource(init.tcl) {
-# Copyright (c) 2010 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# Module to help create auto.def and configure
-
-proc autosetup_init {type} {
-	set help 0
-	if {$type in {? help}} {
-		incr help
-	} elseif {![dict exists $::autosetup(inittypes) $type]} {
-		puts "Unknown type, --init=$type"
-		incr help
-	}
-	if {$help} {
-		puts "Use one of the following types (e.g. --init=make)\n"
-		foreach type [lsort [dict keys $::autosetup(inittypes)]] {
-			lassign [dict get $::autosetup(inittypes) $type] desc
-			# XXX: Use the options-show code to wrap the description
-			puts [format "%-10s %s" $type $desc]
-		}
-		return
-	}
-	lassign [dict get $::autosetup(inittypes) $type] desc script
-
-	puts "Initialising $type: $desc\n"
-
-	# All initialisations happens in the top level srcdir
-	cd $::autosetup(srcdir)
-
-	uplevel #0 $script
-}
-
-proc autosetup_add_init_type {type desc script} {
-	dict set ::autosetup(inittypes) $type [list $desc $script]
-}
-
-# This is for in creating build-system init scripts
-#
-# If the file doesn't exist, create it containing $contents
-# If the file does exist, only overwrite if --force is specified.
-#
-proc autosetup_check_create {filename contents} {
-	if {[file exists $filename]} {
-		if {!$::autosetup(force)} {
-			puts "I see $filename already exists."
-			return
-		} else {
-			puts "I will overwrite the existing $filename because you used --force."
-		}
-	} else {
-		puts "I don't see $filename, so I will create it."
-	}
-	writefile $filename $contents
-}
-}
-
-# ----- @module install.tcl -----
-
-set modsource(install.tcl) {
-# Copyright (c) 2006-2010 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# Module which can install autosetup
-
-# autosetup(installed)=1 means that autosetup is not running from source
-# autosetup(sysinstall)=1 means that autosetup is running from a sysinstall version
-# shared=1 means that we are trying to do a sysinstall. This is only possible from the development source.
-
-proc autosetup_install {dir {shared 0}} {
-	global autosetup
-	if {$shared} {
-		if {$autosetup(installed) || $autosetup(sysinstall)} {
-			user-error "Can only --sysinstall from development sources"
-		}
-	} elseif {$autosetup(installed) && !$autosetup(sysinstall)} {
-		user-error "Can't --install from project install"
-	}
-
-	if {$autosetup(sysinstall)} {
-		# This is the sysinstall version, so install just uses references
-		cd $dir
-
-		puts "[autosetup_version] creating configure to use system-installed autosetup"
-		autosetup_create_configure 1
-		puts "Creating autosetup/README.autosetup"
-		file mkdir autosetup
-		autosetup_install_readme autosetup/README.autosetup 1
-		return
-	}
-
-	if {[catch {
-		if {$shared} {
-			set target $dir/bin/autosetup
-			set installedas $target
-		} else {
-			if {$dir eq "."} {
-				set installedas autosetup
-			} else {
-				set installedas $dir/autosetup
-			}
-			cd $dir
-			file mkdir autosetup
-			set target autosetup/autosetup
-		}
-		set targetdir [file dirname $target]
-		file mkdir $targetdir
-
-		set f [open $target w]
-
-		set publicmodules {}
-
-		# First the main script, but only up until "CUT HERE"
-		set in [open $autosetup(dir)/autosetup]
-		while {[gets $in buf] >= 0} {
-			if {$buf ne "##-- CUT HERE --##"} {
-				puts $f $buf
-				continue
-			}
-
-			# Insert the static modules here
-			# i.e. those which don't contain @synopsis:
-			# All modules are inserted if $shared is set
-			puts $f "set autosetup(installed) 1"
-			puts $f "set autosetup(sysinstall) $shared"
-			foreach file [lsort [glob $autosetup(libdir)/*.{tcl,auto}]] {
-				set modname [file tail $file]
-				set ext [file ext $modname]
-				set buf [readfile $file]
-				if {!$shared} {
-					if {$ext eq ".auto" || [string match "*\n# @synopsis:*" $buf]} {
-						lappend publicmodules $file
-						continue
-					}
-				}
-				dputs "install: importing lib/[file tail $file]"
-				puts $f "# ----- @module $modname -----"
-				puts $f "\nset modsource($modname) \{"
-				puts $f $buf
-				puts $f "\}\n"
-			}
-			if {$shared} {
-				foreach {srcname destname} [list $autosetup(libdir)/README.autosetup-lib README.autosetup \
-						$autosetup(srcdir)/LICENSE LICENSE] {
-					dputs "install: importing $srcname as $destname"
-					puts $f "\nset modsource($destname) \\\n[list [readfile $srcname]\n]\n"
-				}
-			}
-		}
-		close $in
-		close $f
-		catch {exec chmod 755 $target}
-
-		set installfiles {autosetup-config.guess autosetup-config.sub autosetup-test-tclsh}
-		set removefiles {}
-
-		if {!$shared} {
-			autosetup_install_readme $targetdir/README.autosetup 0
-
-			# Install public modules
-			foreach file $publicmodules {
-				set tail [file tail $file]
-				autosetup_install_file $file $targetdir/$tail
-			}
-			lappend installfiles jimsh0.c autosetup-find-tclsh LICENSE
-			lappend removefiles config.guess config.sub test-tclsh find-tclsh
-		} else {
-			lappend installfiles {sys-find-tclsh autosetup-find-tclsh}
-		}
-
-		# Install support files
-		foreach fileinfo $installfiles {
-			if {[llength $fileinfo] == 2} {
-				lassign $fileinfo source dest
-			} else {
-				lassign $fileinfo source
-				set dest $source
-			}
-			autosetup_install_file $autosetup(dir)/$source $targetdir/$dest
-		}
-
-		# Remove obsolete files
-		foreach file $removefiles {
-			if {[file exists $targetdir/$file]} {
-				file delete $targetdir/$file
-			}
-		}
-	} error]} {
-		user-error "Failed to install autosetup: $error"
-	}
-	if {$shared} {
-		set type "system"
-	} else {
-		set type "local"
-	}
-	puts "Installed $type [autosetup_version] to $installedas"
-
-	if {!$shared} {
-		# Now create 'configure' if necessary
-		autosetup_create_configure 0
-	}
-}
-
-proc autosetup_create_configure {shared} {
-	if {[file exists configure]} {
-		if {!$::autosetup(force)} {
-			# Could this be an autosetup configure?
-			if {![string match "*\nWRAPPER=*" [readfile configure]]} {
-				puts "I see configure, but not created by autosetup, so I won't overwrite it."
-				puts "Remove it or use --force to overwrite."
-				return
-			}
-		} else {
-			puts "I will overwrite the existing configure because you used --force."
-		}
-	} else {
-		puts "I don't see configure, so I will create it."
-	}
-	if {$shared} {
-		writefile configure \
-{#!/bin/sh
-WRAPPER="$0"; export WRAPPER; "autosetup" "$@"
-}
-	} else {
-		writefile configure \
-{#!/bin/sh
-dir="`dirname "$0"`/autosetup"
-#@@INITCHECK@@#
-WRAPPER="$0"; export WRAPPER; exec "`"$dir/autosetup-find-tclsh"`" "$dir/autosetup" "$@"
-}
-	}
-	catch {exec chmod 755 configure}
-}
-
-# Append the contents of $file to filehandle $f
-proc autosetup_install_append {f file} {
-	dputs "install: include $file"
-	set in [open $file]
-	puts $f [read $in]
-	close $in
-}
-
-proc autosetup_install_file {source target} {
-	dputs "install: $source => $target"
-	if {![file exists $source]} {
-		error "Missing installation file '$source'"
-	}
-	writefile $target [readfile $source]\n
-	# If possible, copy the file mode
-	file stat $source stat
-	set mode [format %o [expr {$stat(mode) & 0x1ff}]]
-	catch {exec chmod $mode $target}
-}
-
-proc autosetup_install_readme {target sysinstall} {
-	set readme "README.autosetup created by [autosetup_version]\n\n"
-	if {$sysinstall} {
-		append readme \
-{This is the autosetup directory for a system install of autosetup.
-Loadable modules can be added here.
-}
-	} else {
-		append readme \
-{This is the autosetup directory for a local install of autosetup.
-It contains autosetup, support files and loadable modules.
-}
-}
-
-	append readme {
-*.tcl files in this directory are optional modules which
-can be loaded with the 'use' directive.
-
-*.auto files in this directory are auto-loaded.
-
-For more information, see https://msteveb.github.io/autosetup/
-}
-	dputs "install: autosetup/README.autosetup"
-	writefile $target $readme
-}
-}
-
-# ----- @module markdown-formatting.tcl -----
-
-set modsource(markdown-formatting.tcl) {
-# Copyright (c) 2010 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# Module which provides text formatting
-# markdown format (kramdown syntax)
-
-use formatting
-
-proc para {text} {
-    regsub -all "\[ \t\n\]+" [string trim $text] " " text
-    regsub -all {([^a-zA-Z])'([^']*)'} $text {\1**`\2`**} text
-    regsub -all {^'([^']*)'} $text {**`\1`**} text
-    regsub -all {(http[^ \t\n]*)} $text {[\1](\1)} text
-    return $text
-}
-proc title {text} {
-    underline [para $text] =
-    nl
-}
-proc p {text} {
-    puts [para $text]
-    nl
-}
-proc codelines {lines} {
-    puts "~~~~~~~~~~~~"
-    foreach line $lines {
-        puts $line
-    }
-    puts "~~~~~~~~~~~~"
-    nl
-}
-proc code {text} {
-    puts "~~~~~~~~~~~~"
-    foreach line [parse_code_block $text] {
-        puts $line
-    }
-    puts "~~~~~~~~~~~~"
-    nl
-}
-proc nl {} {
-    puts ""
-}
-proc underline {text char} {
-    regexp "^(\[ \t\]*)(.*)" $text -> indent words
-    puts $text
-    puts $indent[string repeat $char [string length $words]]
-}
-proc section {text} {
-    underline "[para $text]" -
-    nl
-}
-proc subsection {text} {
-    puts "### `$text`"
-    nl
-}
-proc bullet {text} {
-    puts "* [para $text]"
-}
-proc defn {first args} {
-    puts "^"
-    set defn [string trim [join $args \n]]
-    if {$first ne ""} {
-        puts "**${first}**"
-        puts -nonewline ": "
-        regsub -all "\n\n" $defn "\n: " defn
-    }
-    puts "$defn"
-}
-}
-
-# ----- @module misc.tcl -----
-
-set modsource(misc.tcl) {
-# Copyright (c) 2007-2010 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# Module containing misc procs useful to modules
-# Largely for platform compatibility
-
-set autosetup(istcl) [info exists ::tcl_library]
-set autosetup(iswin) [string equal windows $tcl_platform(platform)]
-
-if {$autosetup(iswin)} {
-	# mingw/windows separates $PATH with semicolons
-	# and doesn't have an executable bit
-	proc split-path {} {
-		split [getenv PATH .] {;}
-	}
-	proc file-isexec {exec} {
-		# Basic test for windows. We ignore .bat
-		if {[file isfile $exec] || [file isfile $exec.exe]} {
-			return 1
-		}
-		return 0
-	}
-} else {
-	# unix separates $PATH with colons and has and executable bit
-	proc split-path {} {
-		split [getenv PATH .] :
-	}
-	# Check for an executable file
-	proc file-isexec {exec} {
-		if {[file executable $exec] && [file isfile $exec]} {
-			return 1
-		}
-		return 0
-	}
-}
-
-# Assume that exec can return stdout and stderr
-proc exec-with-stderr {args} {
-	exec {*}$args 2>@1
-}
-
-if {$autosetup(istcl)} {
-	# Tcl doesn't have the env command
-	proc getenv {name args} {
-		if {[info exists ::env($name)]} {
-			return $::env($name)
-		}
-		if {[llength $args]} {
-			return [lindex $args 0]
-		}
-		return -code error "environment variable \"$name\" does not exist"
-	}
-	proc isatty? {channel} {
-		dict exists [fconfigure $channel] -xchar
-	}
-	# Jim-compatible stacktrace using info frame
-	proc stacktrace {} {
-		set stacktrace {}
-		# 2 to skip the current frame
-		for {set i 2} {$i < [info frame]} {incr i} {
-			set frame [info frame -$i]
-			if {[dict exists $frame file]} {
-				# We don't need proc, so use ""
-				lappend stacktrace "" [dict get $frame file] [dict get $frame line] ""
-			}
-		}
-		return $stacktrace
-	}
-} else {
-	if {$autosetup(iswin)} {
-		# On Windows, backslash convert all environment variables
-		# (Assume that Tcl does this for us)
-		proc getenv {name args} {
-			string map {\\ /} [env $name {*}$args]
-		}
-	} else {
-		# Jim on unix is simple
-		alias getenv env
-	}
-	proc isatty? {channel} {
-		set tty 0
-		catch {
-			# isatty is a recent addition to Jim Tcl
-			set tty [$channel isatty]
-		}
-		return $tty
-	}
-}
-
-# In case 'file normalize' doesn't exist
-#
-proc file-normalize {path} {
-	if {[catch {file normalize $path} result]} {
-		if {$path eq ""} {
-			return ""
-		}
-		set oldpwd [pwd]
-		if {[file isdir $path]} {
-			cd $path
-			set result [pwd]
-		} else {
-			cd [file dirname $path]
-			set result [file join [pwd] [file tail $path]]
-		}
-		cd $oldpwd
-	}
-	return $result
-}
-
-# If everything is working properly, the only errors which occur
-# should be generated in user code (e.g. auto.def).
-# By default, we only want to show the error location in user code.
-# We use [info frame] to achieve this, but it works differently on Tcl and Jim.
-#
-# This is designed to be called for incorrect usage in auto.def, via autosetup-error
-#
-proc error-location {msg} {
-	if {$::autosetup(debug)} {
-		return -code error $msg
-	}
-	set vars {p f l cmd}
-	if {!$::autosetup(istcl) && ![dict exists $::tcl_platform stackFormat]} {
-		# Older versions of Jim had a 3 element stacktrace
-		set vars {p f l}
-	}
-	foreach $vars [stacktrace] {
-		if {[string match *.def $f]} {
-			return "[relative-path $f]:$l: Error: $msg"
-		}
-		#puts "Skipping $f:$l"
-	}
-	return $msg
-}
-
-# If everything is working properly, the only errors which occur
-# should be generated in user code (e.g. auto.def).
-# By default, we only want to show the error location in user code.
-# We use [info frame] to achieve this, but it works differently on Tcl and Jim.
-#
-# This is designed to be called for incorrect usage in auto.def, via autosetup-error
-#
-proc error-stacktrace {msg} {
-	if {$::autosetup(debug)} {
-		return -code error $msg
-	}
-	# Search back through the stack trace for the first error in a .def file
-	for {set i 1} {$i < [info level]} {incr i} {
-		if {$::autosetup(istcl)} {
-			array set info [info frame -$i]
-		} else {
-			lassign [info frame -$i] info(caller) info(file) info(line)
-		}
-		if {[string match *.def $info(file)]} {
-			return "[relative-path $info(file)]:$info(line): Error: $msg"
-		}
-		#puts "Skipping $info(file):$info(line)"
-	}
-	return $msg
-}
-
-# Given the return from [catch {...} msg opts], returns an appropriate
-# error message. A nice one for Jim and a less-nice one for Tcl.
-# If 'fulltrace' is set, a full stack trace is provided.
-# Otherwise a simple message is provided.
-#
-# This is designed for developer errors, e.g. in module code or auto.def code
-#
-#
-proc error-dump {msg opts fulltrace} {
-	if {$::autosetup(istcl)} {
-		if {$fulltrace} {
-			return "Error: [dict get $opts -errorinfo]"
-		} else {
-			return "Error: $msg"
-		}
-	} else {
-		lassign $opts(-errorinfo) p f l
-		if {$f ne ""} {
-			set result "$f:$l: Error: "
-		}
-		append result "$msg\n"
-		if {$fulltrace} {
-			append result [stackdump $opts(-errorinfo)]
-		}
-
-		# Remove the trailing newline
-		string trim $result
-	}
-}
-}
-
-# ----- @module text-formatting.tcl -----
-
-set modsource(text-formatting.tcl) {
-# Copyright (c) 2010 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# Module which provides text formatting
-
-use formatting
-
-proc wordwrap {text length {firstprefix ""} {nextprefix ""}} {
-	set len 0
-	set space $firstprefix
-
-	foreach word [split $text] {
-		set word [string trim $word]
-		if {$word eq ""} {
-			continue
-		}
-		if {[info exists partial]} {
-			append partial " " $word
-			if {[string first $quote $word] < 0} {
-				# Haven't found end of quoted word
-				continue
-			}
-			# Finished quoted word
-			set word $partial
-			unset partial
-			unset quote
-		} else {
-			set quote [string index $word 0]
-			if {$quote in {' *}} {
-				if {[string first $quote $word 1] < 0} {
-					# Haven't found end of quoted word
-					# Not a whole word.
-					set first [string index $word 0]
-					# Start of quoted word
-					set partial $word
-					continue
-				}
-			}
-		}
-
-		if {$len && [string length $space$word] + $len >= $length} {
-			puts ""
-			set len 0
-			set space $nextprefix
-		}
-		incr len [string length $space$word]
-
-		# Use man-page conventions for highlighting 'quoted' and *quoted*
-		# single words.
-		# Use x^Hx for *bold* and _^Hx for 'underline'.
-		#
-		# less and more will both understand this.
-		# Pipe through 'col -b' to remove them.
-		if {[regexp {^'(.*)'(.*)} $word -> quoted after]} {
-			set quoted [string map {~ " "} $quoted]
-			regsub -all . $quoted "&\b&" quoted
-			set word $quoted$after
-		} elseif {[regexp {^[*](.*)[*](.*)} $word -> quoted after]} {
-			set quoted [string map {~ " "} $quoted]
-			regsub -all . $quoted "_\b&" quoted
-			set word $quoted$after
-		}
-		puts -nonewline $space$word
-		set space " "
-	}
-	if {[info exists partial]} {
-		# Missing end of quote
-		puts -nonewline $space$partial
-	}
-	if {$len} {
-		puts ""
-	}
-}
-proc title {text} {
-	underline [string trim $text] =
-	nl
-}
-proc p {text} {
-	wordwrap $text 80
-	nl
-}
-proc codelines {lines} {
-	foreach line $lines {
-		puts "	  $line"
-	}
-	nl
-}
-proc nl {} {
-	puts ""
-}
-proc underline {text char} {
-	regexp "^(\[ \t\]*)(.*)" $text -> indent words
-	puts $text
-	puts $indent[string repeat $char [string length $words]]
-}
-proc section {text} {
-	underline "[string trim $text]" -
-	nl
-}
-proc subsection {text} {
-	underline "$text" ~
-	nl
-}
-proc bullet {text} {
-	wordwrap $text 76 "	 * " "	  "
-}
-proc indent {text} {
-	wordwrap $text 76 "	   " "	  "
-}
-proc defn {first args} {
-	if {$first ne ""} {
-		underline "	   $first" ~
-	}
-	foreach p $args {
-		if {$p ne ""} {
-			indent $p
-		}
-	}
-}
-}
-
-# ----- @module util.tcl -----
-
-set modsource(util.tcl) {
-# Copyright (c) 2012 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# Module which contains miscellaneous utility functions
-
-# @section Utilities
-
-# @compare-versions version1 version2
-#
-# Versions are of the form 'a.b.c' (may be any number of numeric components)
-#
-# Compares the two versions and returns:
-## -1 if v1 < v2
-##  0 if v1 == v2
-##  1 if v1 > v2
-#
-# If one version has fewer components than the other, 0 is substituted to the right. e.g.
-## 0.2   <  0.3
-## 0.2.5 >  0.2
-## 1.1   == 1.1.0
-#
-proc compare-versions {v1 v2} {
-	foreach c1 [split $v1 .] c2 [split $v2 .] {
-		if {$c1 eq ""} {
-			set c1 0
-		}
-		if {$c2 eq ""} {
-			set c2 0
-		}
-		if {$c1 < $c2} {
-			return -1
-		}
-		if {$c1 > $c2} {
-			return 1
-		}
-	}
-	return 0
-}
-
-# @suffix suf list
-#
-# Takes a list and returns a new list with '$suf' appended
-# to each element
-#
-## suffix .c {a b c} => {a.c b.c c.c}
-#
-proc suffix {suf list} {
-	set result {}
-	foreach p $list {
-		lappend result $p$suf
-	}
-	return $result
-}
-
-# @prefix pre list
-#
-# Takes a list and returns a new list with '$pre' prepended
-# to each element
-#
-## prefix jim- {a.c b.c} => {jim-a.c jim-b.c}
-#
-proc prefix {pre list} {
-	set result {}
-	foreach p $list {
-		lappend result $pre$p
-	}
-	return $result
-}
-
-# @lpop list
-#
-# Removes the last entry from the given list and returns it.
-proc lpop {listname} {
-	upvar $listname list
-	set val [lindex $list end]
-	set list [lrange $list 0 end-1]
-	return $val
-}
-}
-
-# ----- @module wiki-formatting.tcl -----
-
-set modsource(wiki-formatting.tcl) {
-# Copyright (c) 2010 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# Module which provides text formatting
-# wiki.tcl.tk format output
-
-use formatting
-
-proc joinlines {text} {
-    set lines {}
-    foreach l [split [string trim $text] \n] {
-        lappend lines [string trim $l]
-    }
-    join $lines
-}
-proc p {text} {
-    puts [joinlines $text]
-    puts ""
-}
-proc title {text} {
-    puts "*** [joinlines $text] ***"
-    puts ""
-}
-proc codelines {lines} {
-    puts "======"
-    foreach line $lines {
-        puts "    $line"
-    }
-    puts "======"
-}
-proc code {text} {
-    puts "======"
-    foreach line [parse_code_block $text] {
-        puts "    $line"
-    }
-    puts "======"
-}
-proc nl {} {
-}
-proc section {text} {
-    puts "'''$text'''"
-    puts ""
-}
-proc subsection {text} {
-    puts "''$text''"
-    puts ""
-}
-proc bullet {text} {
-    puts "   * [joinlines $text]"
-}
-proc indent {text} {
-    puts "    :    [joinlines $text]"
-}
-proc defn {first args} {
-    if {$first ne ""} {
-        indent '''$first'''
-    }
-
-    foreach p $args {
-        p $p
-    }
-}
-}
-
-
-##################################################################
-#
-# Entry/Exit
-#
-if {$autosetup(debug)} {
-	main $argv
-}
-if {[catch {main $argv} msg opts] == 1} {
-	show-notices
-	autosetup-full-error [error-dump $msg $opts $autosetup(debug)]
-	if {!$autosetup(debug)} {
-		puts stderr "Try: '[file tail $autosetup(exe)] --debug' for a full stack trace"
-	}
-	exit 1
-}
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup-config.guess b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup-config.guess
deleted file mode 100644
index 48a6846..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup-config.guess
+++ /dev/null
@@ -1,1815 +0,0 @@
-#! /bin/sh
-# Attempt to guess a canonical system name.
-#   Copyright 1992-2024 Free Software Foundation, Inc.
-
-# shellcheck disable=SC2006,SC2268 # see below for rationale
-
-timestamp='2024-07-27'
-
-# This file is free software; you can redistribute it and/or modify it
-# under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, see <https://www.gnu.org/licenses/>.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that
-# program.  This Exception is an additional permission under section 7
-# of the GNU General Public License, version 3 ("GPLv3").
-#
-# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
-#
-# You can get the latest version of this script from:
-# https://git.savannah.gnu.org/cgit/config.git/plain/config.guess
-#
-# Please send patches to <config-patches@gnu.org>.
-
-
-# The "shellcheck disable" line above the timestamp inhibits complaints
-# about features and limitations of the classic Bourne shell that were
-# superseded or lifted in POSIX.  However, this script identifies a wide
-# variety of pre-POSIX systems that do not have POSIX shells at all, and
-# even some reasonably current systems (Solaris 10 as case-in-point) still
-# have a pre-POSIX /bin/sh.
-
-
-me=`echo "$0" | sed -e 's,.*/,,'`
-
-usage="\
-Usage: $0 [OPTION]
-
-Output the configuration name of the system '$me' is run on.
-
-Options:
-  -h, --help         print this help, then exit
-  -t, --time-stamp   print date of last modification, then exit
-  -v, --version      print version number, then exit
-
-Report bugs and patches to <config-patches@gnu.org>."
-
-version="\
-GNU config.guess ($timestamp)
-
-Originally written by Per Bothner.
-Copyright 1992-2024 Free Software Foundation, Inc.
-
-This is free software; see the source for copying conditions.  There is NO
-warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
-
-help="
-Try '$me --help' for more information."
-
-# Parse command line
-while test $# -gt 0 ; do
-  case $1 in
-    --time-stamp | --time* | -t )
-       echo "$timestamp" ; exit ;;
-    --version | -v )
-       echo "$version" ; exit ;;
-    --help | --h* | -h )
-       echo "$usage"; exit ;;
-    -- )     # Stop option processing
-       shift; break ;;
-    - )	# Use stdin as input.
-       break ;;
-    -* )
-       echo "$me: invalid option $1$help" >&2
-       exit 1 ;;
-    * )
-       break ;;
-  esac
-done
-
-if test $# != 0; then
-  echo "$me: too many arguments$help" >&2
-  exit 1
-fi
-
-# Just in case it came from the environment.
-GUESS=
-
-# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
-# compiler to aid in system detection is discouraged as it requires
-# temporary files to be created and, as you can see below, it is a
-# headache to deal with in a portable fashion.
-
-# Historically, 'CC_FOR_BUILD' used to be named 'HOST_CC'. We still
-# use 'HOST_CC' if defined, but it is deprecated.
-
-# Portable tmp directory creation inspired by the Autoconf team.
-
-tmp=
-# shellcheck disable=SC2172
-trap 'test -z "$tmp" || rm -fr "$tmp"' 0 1 2 13 15
-
-set_cc_for_build() {
-    # prevent multiple calls if $tmp is already set
-    test "$tmp" && return 0
-    : "${TMPDIR=/tmp}"
-    # shellcheck disable=SC2039,SC3028
-    { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
-	{ test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir "$tmp" 2>/dev/null) ; } ||
-	{ tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir "$tmp" 2>/dev/null) && echo "Warning: creating insecure temp directory" >&2 ; } ||
-	{ echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; }
-    dummy=$tmp/dummy
-    case ${CC_FOR_BUILD-},${HOST_CC-},${CC-} in
-	,,)    echo "int x;" > "$dummy.c"
-	       for driver in cc gcc c17 c99 c89 ; do
-		   if ($driver -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then
-		       CC_FOR_BUILD=$driver
-		       break
-		   fi
-	       done
-	       if test x"$CC_FOR_BUILD" = x ; then
-		   CC_FOR_BUILD=no_compiler_found
-	       fi
-	       ;;
-	,,*)   CC_FOR_BUILD=$CC ;;
-	,*,*)  CC_FOR_BUILD=$HOST_CC ;;
-    esac
-}
-
-# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
-# (ghazi@noc.rutgers.edu 1994-08-24)
-if test -f /.attbin/uname ; then
-	PATH=$PATH:/.attbin ; export PATH
-fi
-
-UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
-UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
-UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
-UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
-
-case $UNAME_SYSTEM in
-Linux|GNU|GNU/*)
-	LIBC=unknown
-
-	set_cc_for_build
-	cat <<-EOF > "$dummy.c"
-	#if defined(__ANDROID__)
-	LIBC=android
-	#else
-	#include <features.h>
-	#if defined(__UCLIBC__)
-	LIBC=uclibc
-	#elif defined(__dietlibc__)
-	LIBC=dietlibc
-	#elif defined(__GLIBC__)
-	LIBC=gnu
-	#elif defined(__LLVM_LIBC__)
-	LIBC=llvm
-	#else
-	#include <stdarg.h>
-	/* First heuristic to detect musl libc.  */
-	#ifdef __DEFINED_va_list
-	LIBC=musl
-	#endif
-	#endif
-	#endif
-	EOF
-	cc_set_libc=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`
-	eval "$cc_set_libc"
-
-	# Second heuristic to detect musl libc.
-	if [ "$LIBC" = unknown ] &&
-	   command -v ldd >/dev/null &&
-	   ldd --version 2>&1 | grep -q ^musl; then
-		LIBC=musl
-	fi
-
-	# If the system lacks a compiler, then just pick glibc.
-	# We could probably try harder.
-	if [ "$LIBC" = unknown ]; then
-		LIBC=gnu
-	fi
-	;;
-esac
-
-# Note: order is significant - the case branches are not exclusive.
-
-case $UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION in
-    *:NetBSD:*:*)
-	# NetBSD (nbsd) targets should (where applicable) match one or
-	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
-	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
-	# switched to ELF, *-*-netbsd* would select the old
-	# object file format.  This provides both forward
-	# compatibility and a consistent mechanism for selecting the
-	# object file format.
-	#
-	# Note: NetBSD doesn't particularly care about the vendor
-	# portion of the name.  We always set it to "unknown".
-	UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \
-	    /sbin/sysctl -n hw.machine_arch 2>/dev/null || \
-	    /usr/sbin/sysctl -n hw.machine_arch 2>/dev/null || \
-	    echo unknown)`
-	case $UNAME_MACHINE_ARCH in
-	    aarch64eb) machine=aarch64_be-unknown ;;
-	    armeb) machine=armeb-unknown ;;
-	    arm*) machine=arm-unknown ;;
-	    sh3el) machine=shl-unknown ;;
-	    sh3eb) machine=sh-unknown ;;
-	    sh5el) machine=sh5le-unknown ;;
-	    earmv*)
-		arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'`
-		endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'`
-		machine=${arch}${endian}-unknown
-		;;
-	    *) machine=$UNAME_MACHINE_ARCH-unknown ;;
-	esac
-	# The Operating System including object format, if it has switched
-	# to ELF recently (or will in the future) and ABI.
-	case $UNAME_MACHINE_ARCH in
-	    earm*)
-		os=netbsdelf
-		;;
-	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
-		set_cc_for_build
-		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
-			| grep -q __ELF__
-		then
-		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
-		    # Return netbsd for either.  FIX?
-		    os=netbsd
-		else
-		    os=netbsdelf
-		fi
-		;;
-	    *)
-		os=netbsd
-		;;
-	esac
-	# Determine ABI tags.
-	case $UNAME_MACHINE_ARCH in
-	    earm*)
-		expr='s/^earmv[0-9]/-eabi/;s/eb$//'
-		abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"`
-		;;
-	esac
-	# The OS release
-	# Debian GNU/NetBSD machines have a different userland, and
-	# thus, need a distinct triplet. However, they do not need
-	# kernel version information, so it can be replaced with a
-	# suitable tag, in the style of linux-gnu.
-	case $UNAME_VERSION in
-	    Debian*)
-		release='-gnu'
-		;;
-	    *)
-		release=`echo "$UNAME_RELEASE" | sed -e 's/[-_].*//' | cut -d. -f1,2`
-		;;
-	esac
-	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
-	# contains redundant information, the shorter form:
-	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
-	GUESS=$machine-${os}${release}${abi-}
-	;;
-    *:Bitrig:*:*)
-	UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
-	GUESS=$UNAME_MACHINE_ARCH-unknown-bitrig$UNAME_RELEASE
-	;;
-    *:OpenBSD:*:*)
-	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
-	GUESS=$UNAME_MACHINE_ARCH-unknown-openbsd$UNAME_RELEASE
-	;;
-    *:SecBSD:*:*)
-	UNAME_MACHINE_ARCH=`arch | sed 's/SecBSD.//'`
-	GUESS=$UNAME_MACHINE_ARCH-unknown-secbsd$UNAME_RELEASE
-	;;
-    *:LibertyBSD:*:*)
-	UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'`
-	GUESS=$UNAME_MACHINE_ARCH-unknown-libertybsd$UNAME_RELEASE
-	;;
-    *:MidnightBSD:*:*)
-	GUESS=$UNAME_MACHINE-unknown-midnightbsd$UNAME_RELEASE
-	;;
-    *:ekkoBSD:*:*)
-	GUESS=$UNAME_MACHINE-unknown-ekkobsd$UNAME_RELEASE
-	;;
-    *:SolidBSD:*:*)
-	GUESS=$UNAME_MACHINE-unknown-solidbsd$UNAME_RELEASE
-	;;
-    *:OS108:*:*)
-	GUESS=$UNAME_MACHINE-unknown-os108_$UNAME_RELEASE
-	;;
-    macppc:MirBSD:*:*)
-	GUESS=powerpc-unknown-mirbsd$UNAME_RELEASE
-	;;
-    *:MirBSD:*:*)
-	GUESS=$UNAME_MACHINE-unknown-mirbsd$UNAME_RELEASE
-	;;
-    *:Sortix:*:*)
-	GUESS=$UNAME_MACHINE-unknown-sortix
-	;;
-    *:Twizzler:*:*)
-	GUESS=$UNAME_MACHINE-unknown-twizzler
-	;;
-    *:Redox:*:*)
-	GUESS=$UNAME_MACHINE-unknown-redox
-	;;
-    mips:OSF1:*.*)
-	GUESS=mips-dec-osf1
-	;;
-    alpha:OSF1:*:*)
-	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
-	trap '' 0
-	case $UNAME_RELEASE in
-	*4.0)
-		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
-		;;
-	*5.*)
-		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
-		;;
-	esac
-	# According to Compaq, /usr/sbin/psrinfo has been available on
-	# OSF/1 and Tru64 systems produced since 1995.  I hope that
-	# covers most systems running today.  This code pipes the CPU
-	# types through head -n 1, so we only detect the type of CPU 0.
-	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
-	case $ALPHA_CPU_TYPE in
-	    "EV4 (21064)")
-		UNAME_MACHINE=alpha ;;
-	    "EV4.5 (21064)")
-		UNAME_MACHINE=alpha ;;
-	    "LCA4 (21066/21068)")
-		UNAME_MACHINE=alpha ;;
-	    "EV5 (21164)")
-		UNAME_MACHINE=alphaev5 ;;
-	    "EV5.6 (21164A)")
-		UNAME_MACHINE=alphaev56 ;;
-	    "EV5.6 (21164PC)")
-		UNAME_MACHINE=alphapca56 ;;
-	    "EV5.7 (21164PC)")
-		UNAME_MACHINE=alphapca57 ;;
-	    "EV6 (21264)")
-		UNAME_MACHINE=alphaev6 ;;
-	    "EV6.7 (21264A)")
-		UNAME_MACHINE=alphaev67 ;;
-	    "EV6.8CB (21264C)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.8AL (21264B)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.8CX (21264D)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.9A (21264/EV69A)")
-		UNAME_MACHINE=alphaev69 ;;
-	    "EV7 (21364)")
-		UNAME_MACHINE=alphaev7 ;;
-	    "EV7.9 (21364A)")
-		UNAME_MACHINE=alphaev79 ;;
-	esac
-	# A Pn.n version is a patched version.
-	# A Vn.n version is a released version.
-	# A Tn.n version is a released field test version.
-	# A Xn.n version is an unreleased experimental baselevel.
-	# 1.2 uses "1.2" for uname -r.
-	OSF_REL=`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
-	GUESS=$UNAME_MACHINE-dec-osf$OSF_REL
-	;;
-    Amiga*:UNIX_System_V:4.0:*)
-	GUESS=m68k-unknown-sysv4
-	;;
-    *:[Aa]miga[Oo][Ss]:*:*)
-	GUESS=$UNAME_MACHINE-unknown-amigaos
-	;;
-    *:[Mm]orph[Oo][Ss]:*:*)
-	GUESS=$UNAME_MACHINE-unknown-morphos
-	;;
-    *:OS/390:*:*)
-	GUESS=i370-ibm-openedition
-	;;
-    *:z/VM:*:*)
-	GUESS=s390-ibm-zvmoe
-	;;
-    *:OS400:*:*)
-	GUESS=powerpc-ibm-os400
-	;;
-    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
-	GUESS=arm-acorn-riscix$UNAME_RELEASE
-	;;
-    arm*:riscos:*:*|arm*:RISCOS:*:*)
-	GUESS=arm-unknown-riscos
-	;;
-    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
-	GUESS=hppa1.1-hitachi-hiuxmpp
-	;;
-    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
-	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
-	case `(/bin/universe) 2>/dev/null` in
-	    att) GUESS=pyramid-pyramid-sysv3 ;;
-	    *)   GUESS=pyramid-pyramid-bsd   ;;
-	esac
-	;;
-    NILE*:*:*:dcosx)
-	GUESS=pyramid-pyramid-svr4
-	;;
-    DRS?6000:unix:4.0:6*)
-	GUESS=sparc-icl-nx6
-	;;
-    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
-	case `/usr/bin/uname -p` in
-	    sparc) GUESS=sparc-icl-nx7 ;;
-	esac
-	;;
-    s390x:SunOS:*:*)
-	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
-	GUESS=$UNAME_MACHINE-ibm-solaris2$SUN_REL
-	;;
-    sun4H:SunOS:5.*:*)
-	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
-	GUESS=sparc-hal-solaris2$SUN_REL
-	;;
-    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
-	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
-	GUESS=sparc-sun-solaris2$SUN_REL
-	;;
-    i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
-	GUESS=i386-pc-auroraux$UNAME_RELEASE
-	;;
-    i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
-	set_cc_for_build
-	SUN_ARCH=i386
-	# If there is a compiler, see if it is configured for 64-bit objects.
-	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
-	# This test works for both compilers.
-	if test "$CC_FOR_BUILD" != no_compiler_found; then
-	    if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
-		(CCOPTS="" $CC_FOR_BUILD -m64 -E - 2>/dev/null) | \
-		grep IS_64BIT_ARCH >/dev/null
-	    then
-		SUN_ARCH=x86_64
-	    fi
-	fi
-	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
-	GUESS=$SUN_ARCH-pc-solaris2$SUN_REL
-	;;
-    sun4*:SunOS:6*:*)
-	# According to config.sub, this is the proper way to canonicalize
-	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
-	# it's likely to be more like Solaris than SunOS4.
-	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
-	GUESS=sparc-sun-solaris3$SUN_REL
-	;;
-    sun4*:SunOS:*:*)
-	case `/usr/bin/arch -k` in
-	    Series*|S4*)
-		UNAME_RELEASE=`uname -v`
-		;;
-	esac
-	# Japanese Language versions have a version number like '4.1.3-JL'.
-	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/'`
-	GUESS=sparc-sun-sunos$SUN_REL
-	;;
-    sun3*:SunOS:*:*)
-	GUESS=m68k-sun-sunos$UNAME_RELEASE
-	;;
-    sun*:*:4.2BSD:*)
-	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
-	test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3
-	case `/bin/arch` in
-	    sun3)
-		GUESS=m68k-sun-sunos$UNAME_RELEASE
-		;;
-	    sun4)
-		GUESS=sparc-sun-sunos$UNAME_RELEASE
-		;;
-	esac
-	;;
-    aushp:SunOS:*:*)
-	GUESS=sparc-auspex-sunos$UNAME_RELEASE
-	;;
-    # The situation for MiNT is a little confusing.  The machine name
-    # can be virtually everything (everything which is not
-    # "atarist" or "atariste" at least should have a processor
-    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
-    # to the lowercase version "mint" (or "freemint").  Finally
-    # the system name "TOS" denotes a system which is actually not
-    # MiNT.  But MiNT is downward compatible to TOS, so this should
-    # be no problem.
-    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
-	GUESS=m68k-atari-mint$UNAME_RELEASE
-	;;
-    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
-	GUESS=m68k-atari-mint$UNAME_RELEASE
-	;;
-    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
-	GUESS=m68k-atari-mint$UNAME_RELEASE
-	;;
-    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
-	GUESS=m68k-milan-mint$UNAME_RELEASE
-	;;
-    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
-	GUESS=m68k-hades-mint$UNAME_RELEASE
-	;;
-    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
-	GUESS=m68k-unknown-mint$UNAME_RELEASE
-	;;
-    m68k:machten:*:*)
-	GUESS=m68k-apple-machten$UNAME_RELEASE
-	;;
-    powerpc:machten:*:*)
-	GUESS=powerpc-apple-machten$UNAME_RELEASE
-	;;
-    RISC*:Mach:*:*)
-	GUESS=mips-dec-mach_bsd4.3
-	;;
-    RISC*:ULTRIX:*:*)
-	GUESS=mips-dec-ultrix$UNAME_RELEASE
-	;;
-    VAX*:ULTRIX*:*:*)
-	GUESS=vax-dec-ultrix$UNAME_RELEASE
-	;;
-    2020:CLIX:*:* | 2430:CLIX:*:*)
-	GUESS=clipper-intergraph-clix$UNAME_RELEASE
-	;;
-    mips:*:*:UMIPS | mips:*:*:RISCos)
-	set_cc_for_build
-	sed 's/^	//' << EOF > "$dummy.c"
-#ifdef __cplusplus
-#include <stdio.h>  /* for printf() prototype */
-	int main (int argc, char *argv[]) {
-#else
-	int main (argc, argv) int argc; char *argv[]; {
-#endif
-	#if defined (host_mips) && defined (MIPSEB)
-	#if defined (SYSTYPE_SYSV)
-	  printf ("mips-mips-riscos%ssysv\\n", argv[1]); exit (0);
-	#endif
-	#if defined (SYSTYPE_SVR4)
-	  printf ("mips-mips-riscos%ssvr4\\n", argv[1]); exit (0);
-	#endif
-	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
-	  printf ("mips-mips-riscos%sbsd\\n", argv[1]); exit (0);
-	#endif
-	#endif
-	  exit (-1);
-	}
-EOF
-	$CC_FOR_BUILD -o "$dummy" "$dummy.c" &&
-	  dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` &&
-	  SYSTEM_NAME=`"$dummy" "$dummyarg"` &&
-	    { echo "$SYSTEM_NAME"; exit; }
-	GUESS=mips-mips-riscos$UNAME_RELEASE
-	;;
-    Motorola:PowerMAX_OS:*:*)
-	GUESS=powerpc-motorola-powermax
-	;;
-    Motorola:*:4.3:PL8-*)
-	GUESS=powerpc-harris-powermax
-	;;
-    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
-	GUESS=powerpc-harris-powermax
-	;;
-    Night_Hawk:Power_UNIX:*:*)
-	GUESS=powerpc-harris-powerunix
-	;;
-    m88k:CX/UX:7*:*)
-	GUESS=m88k-harris-cxux7
-	;;
-    m88k:*:4*:R4*)
-	GUESS=m88k-motorola-sysv4
-	;;
-    m88k:*:3*:R3*)
-	GUESS=m88k-motorola-sysv3
-	;;
-    AViiON:dgux:*:*)
-	# DG/UX returns AViiON for all architectures
-	UNAME_PROCESSOR=`/usr/bin/uname -p`
-	if test "$UNAME_PROCESSOR" = mc88100 || test "$UNAME_PROCESSOR" = mc88110
-	then
-	    if test "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx || \
-	       test "$TARGET_BINARY_INTERFACE"x = x
-	    then
-		GUESS=m88k-dg-dgux$UNAME_RELEASE
-	    else
-		GUESS=m88k-dg-dguxbcs$UNAME_RELEASE
-	    fi
-	else
-	    GUESS=i586-dg-dgux$UNAME_RELEASE
-	fi
-	;;
-    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
-	GUESS=m88k-dolphin-sysv3
-	;;
-    M88*:*:R3*:*)
-	# Delta 88k system running SVR3
-	GUESS=m88k-motorola-sysv3
-	;;
-    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
-	GUESS=m88k-tektronix-sysv3
-	;;
-    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
-	GUESS=m68k-tektronix-bsd
-	;;
-    *:IRIX*:*:*)
-	IRIX_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/g'`
-	GUESS=mips-sgi-irix$IRIX_REL
-	;;
-    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
-	GUESS=romp-ibm-aix    # uname -m gives an 8 hex-code CPU id
-	;;                    # Note that: echo "'`uname -s`'" gives 'AIX '
-    i*86:AIX:*:*)
-	GUESS=i386-ibm-aix
-	;;
-    ia64:AIX:*:*)
-	if test -x /usr/bin/oslevel ; then
-		IBM_REV=`/usr/bin/oslevel`
-	else
-		IBM_REV=$UNAME_VERSION.$UNAME_RELEASE
-	fi
-	GUESS=$UNAME_MACHINE-ibm-aix$IBM_REV
-	;;
-    *:AIX:2:3)
-	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
-		set_cc_for_build
-		sed 's/^		//' << EOF > "$dummy.c"
-		#include <sys/systemcfg.h>
-
-		int
-		main ()
-			{
-			if (!__power_pc())
-				exit(1);
-			puts("powerpc-ibm-aix3.2.5");
-			exit(0);
-			}
-EOF
-		if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"`
-		then
-			GUESS=$SYSTEM_NAME
-		else
-			GUESS=rs6000-ibm-aix3.2.5
-		fi
-	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
-		GUESS=rs6000-ibm-aix3.2.4
-	else
-		GUESS=rs6000-ibm-aix3.2
-	fi
-	;;
-    *:AIX:*:[4567])
-	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
-	if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then
-		IBM_ARCH=rs6000
-	else
-		IBM_ARCH=powerpc
-	fi
-	if test -x /usr/bin/lslpp ; then
-		IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | \
-			   awk -F: '{ print $3 }' | sed s/[0-9]*$/0/`
-	else
-		IBM_REV=$UNAME_VERSION.$UNAME_RELEASE
-	fi
-	GUESS=$IBM_ARCH-ibm-aix$IBM_REV
-	;;
-    *:AIX:*:*)
-	GUESS=rs6000-ibm-aix
-	;;
-    ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*)
-	GUESS=romp-ibm-bsd4.4
-	;;
-    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
-	GUESS=romp-ibm-bsd$UNAME_RELEASE    # 4.3 with uname added to
-	;;                                  # report: romp-ibm BSD 4.3
-    *:BOSX:*:*)
-	GUESS=rs6000-bull-bosx
-	;;
-    DPX/2?00:B.O.S.:*:*)
-	GUESS=m68k-bull-sysv3
-	;;
-    9000/[34]??:4.3bsd:1.*:*)
-	GUESS=m68k-hp-bsd
-	;;
-    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
-	GUESS=m68k-hp-bsd4.4
-	;;
-    9000/[34678]??:HP-UX:*:*)
-	HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'`
-	case $UNAME_MACHINE in
-	    9000/31?)            HP_ARCH=m68000 ;;
-	    9000/[34]??)         HP_ARCH=m68k ;;
-	    9000/[678][0-9][0-9])
-		if test -x /usr/bin/getconf; then
-		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
-		    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
-		    case $sc_cpu_version in
-		      523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0
-		      528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1
-		      532)                      # CPU_PA_RISC2_0
-			case $sc_kernel_bits in
-			  32) HP_ARCH=hppa2.0n ;;
-			  64) HP_ARCH=hppa2.0w ;;
-			  '') HP_ARCH=hppa2.0 ;;   # HP-UX 10.20
-			esac ;;
-		    esac
-		fi
-		if test "$HP_ARCH" = ""; then
-		    set_cc_for_build
-		    sed 's/^		//' << EOF > "$dummy.c"
-
-		#define _HPUX_SOURCE
-		#include <stdlib.h>
-		#include <unistd.h>
-
-		int
-		main ()
-		{
-		#if defined(_SC_KERNEL_BITS)
-		    long bits = sysconf(_SC_KERNEL_BITS);
-		#endif
-		    long cpu  = sysconf (_SC_CPU_VERSION);
-
-		    switch (cpu)
-			{
-			case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
-			case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
-			case CPU_PA_RISC2_0:
-		#if defined(_SC_KERNEL_BITS)
-			    switch (bits)
-				{
-				case 64: puts ("hppa2.0w"); break;
-				case 32: puts ("hppa2.0n"); break;
-				default: puts ("hppa2.0"); break;
-				} break;
-		#else  /* !defined(_SC_KERNEL_BITS) */
-			    puts ("hppa2.0"); break;
-		#endif
-			default: puts ("hppa1.0"); break;
-			}
-		    exit (0);
-		}
-EOF
-		    (CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=`"$dummy"`
-		    test -z "$HP_ARCH" && HP_ARCH=hppa
-		fi ;;
-	esac
-	if test "$HP_ARCH" = hppa2.0w
-	then
-	    set_cc_for_build
-
-	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
-	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
-	    # generating 64-bit code.  GNU and HP use different nomenclature:
-	    #
-	    # $ CC_FOR_BUILD=cc ./config.guess
-	    # => hppa2.0w-hp-hpux11.23
-	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
-	    # => hppa64-hp-hpux11.23
-
-	    if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) |
-		grep -q __LP64__
-	    then
-		HP_ARCH=hppa2.0w
-	    else
-		HP_ARCH=hppa64
-	    fi
-	fi
-	GUESS=$HP_ARCH-hp-hpux$HPUX_REV
-	;;
-    ia64:HP-UX:*:*)
-	HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'`
-	GUESS=ia64-hp-hpux$HPUX_REV
-	;;
-    3050*:HI-UX:*:*)
-	set_cc_for_build
-	sed 's/^	//' << EOF > "$dummy.c"
-	#include <unistd.h>
-	int
-	main ()
-	{
-	  long cpu = sysconf (_SC_CPU_VERSION);
-	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
-	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
-	     results, however.  */
-	  if (CPU_IS_PA_RISC (cpu))
-	    {
-	      switch (cpu)
-		{
-		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
-		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
-		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
-		  default: puts ("hppa-hitachi-hiuxwe2"); break;
-		}
-	    }
-	  else if (CPU_IS_HP_MC68K (cpu))
-	    puts ("m68k-hitachi-hiuxwe2");
-	  else puts ("unknown-hitachi-hiuxwe2");
-	  exit (0);
-	}
-EOF
-	$CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` &&
-		{ echo "$SYSTEM_NAME"; exit; }
-	GUESS=unknown-hitachi-hiuxwe2
-	;;
-    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*)
-	GUESS=hppa1.1-hp-bsd
-	;;
-    9000/8??:4.3bsd:*:*)
-	GUESS=hppa1.0-hp-bsd
-	;;
-    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
-	GUESS=hppa1.0-hp-mpeix
-	;;
-    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*)
-	GUESS=hppa1.1-hp-osf
-	;;
-    hp8??:OSF1:*:*)
-	GUESS=hppa1.0-hp-osf
-	;;
-    i*86:OSF1:*:*)
-	if test -x /usr/sbin/sysversion ; then
-	    GUESS=$UNAME_MACHINE-unknown-osf1mk
-	else
-	    GUESS=$UNAME_MACHINE-unknown-osf1
-	fi
-	;;
-    parisc*:Lites*:*:*)
-	GUESS=hppa1.1-hp-lites
-	;;
-    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
-	GUESS=c1-convex-bsd
-	;;
-    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
-	if getsysinfo -f scalar_acc
-	then echo c32-convex-bsd
-	else echo c2-convex-bsd
-	fi
-	exit ;;
-    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
-	GUESS=c34-convex-bsd
-	;;
-    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
-	GUESS=c38-convex-bsd
-	;;
-    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
-	GUESS=c4-convex-bsd
-	;;
-    CRAY*Y-MP:*:*:*)
-	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
-	GUESS=ymp-cray-unicos$CRAY_REL
-	;;
-    CRAY*[A-Z]90:*:*:*)
-	echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \
-	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
-	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
-	      -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*TS:*:*:*)
-	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
-	GUESS=t90-cray-unicos$CRAY_REL
-	;;
-    CRAY*T3E:*:*:*)
-	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
-	GUESS=alphaev5-cray-unicosmk$CRAY_REL
-	;;
-    CRAY*SV1:*:*:*)
-	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
-	GUESS=sv1-cray-unicos$CRAY_REL
-	;;
-    *:UNICOS/mp:*:*)
-	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
-	GUESS=craynv-cray-unicosmp$CRAY_REL
-	;;
-    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
-	FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
-	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
-	FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'`
-	GUESS=${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}
-	;;
-    5000:UNIX_System_V:4.*:*)
-	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
-	FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'`
-	GUESS=sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}
-	;;
-    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
-	GUESS=$UNAME_MACHINE-pc-bsdi$UNAME_RELEASE
-	;;
-    sparc*:BSD/OS:*:*)
-	GUESS=sparc-unknown-bsdi$UNAME_RELEASE
-	;;
-    *:BSD/OS:*:*)
-	GUESS=$UNAME_MACHINE-unknown-bsdi$UNAME_RELEASE
-	;;
-    arm:FreeBSD:*:*)
-	UNAME_PROCESSOR=`uname -p`
-	set_cc_for_build
-	if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
-	    | grep -q __ARM_PCS_VFP
-	then
-	    FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
-	    GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabi
-	else
-	    FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
-	    GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabihf
-	fi
-	;;
-    *:FreeBSD:*:*)
-	UNAME_PROCESSOR=`uname -p`
-	case $UNAME_PROCESSOR in
-	    amd64)
-		UNAME_PROCESSOR=x86_64 ;;
-	    i386)
-		UNAME_PROCESSOR=i586 ;;
-	esac
-	FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
-	GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL
-	;;
-    i*:CYGWIN*:*)
-	GUESS=$UNAME_MACHINE-pc-cygwin
-	;;
-    *:MINGW64*:*)
-	GUESS=$UNAME_MACHINE-pc-mingw64
-	;;
-    *:MINGW*:*)
-	GUESS=$UNAME_MACHINE-pc-mingw32
-	;;
-    *:MSYS*:*)
-	GUESS=$UNAME_MACHINE-pc-msys
-	;;
-    i*:PW*:*)
-	GUESS=$UNAME_MACHINE-pc-pw32
-	;;
-    *:SerenityOS:*:*)
-        GUESS=$UNAME_MACHINE-pc-serenity
-        ;;
-    *:Interix*:*)
-	case $UNAME_MACHINE in
-	    x86)
-		GUESS=i586-pc-interix$UNAME_RELEASE
-		;;
-	    authenticamd | genuineintel | EM64T)
-		GUESS=x86_64-unknown-interix$UNAME_RELEASE
-		;;
-	    IA64)
-		GUESS=ia64-unknown-interix$UNAME_RELEASE
-		;;
-	esac ;;
-    i*:UWIN*:*)
-	GUESS=$UNAME_MACHINE-pc-uwin
-	;;
-    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
-	GUESS=x86_64-pc-cygwin
-	;;
-    prep*:SunOS:5.*:*)
-	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
-	GUESS=powerpcle-unknown-solaris2$SUN_REL
-	;;
-    *:GNU:*:*)
-	# the GNU system
-	GNU_ARCH=`echo "$UNAME_MACHINE" | sed -e 's,[-/].*$,,'`
-	GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's,/.*$,,'`
-	GUESS=$GNU_ARCH-unknown-$LIBC$GNU_REL
-	;;
-    *:GNU/*:*:*)
-	# other systems with GNU libc and userland
-	GNU_SYS=`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"`
-	GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
-	GUESS=$UNAME_MACHINE-unknown-$GNU_SYS$GNU_REL-$LIBC
-	;;
-    x86_64:[Mm]anagarm:*:*|i?86:[Mm]anagarm:*:*)
-	GUESS="$UNAME_MACHINE-pc-managarm-mlibc"
-	;;
-    *:[Mm]anagarm:*:*)
-	GUESS="$UNAME_MACHINE-unknown-managarm-mlibc"
-	;;
-    *:Minix:*:*)
-	GUESS=$UNAME_MACHINE-unknown-minix
-	;;
-    aarch64:Linux:*:*)
-	set_cc_for_build
-	CPU=$UNAME_MACHINE
-	LIBCABI=$LIBC
-	if test "$CC_FOR_BUILD" != no_compiler_found; then
-	    ABI=64
-	    sed 's/^	    //' << EOF > "$dummy.c"
-	    #ifdef __ARM_EABI__
-	    #ifdef __ARM_PCS_VFP
-	    ABI=eabihf
-	    #else
-	    ABI=eabi
-	    #endif
-	    #endif
-EOF
-	    cc_set_abi=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^ABI' | sed 's, ,,g'`
-	    eval "$cc_set_abi"
-	    case $ABI in
-		eabi | eabihf) CPU=armv8l; LIBCABI=$LIBC$ABI ;;
-	    esac
-	fi
-	GUESS=$CPU-unknown-linux-$LIBCABI
-	;;
-    aarch64_be:Linux:*:*)
-	UNAME_MACHINE=aarch64_be
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    alpha:Linux:*:*)
-	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' /proc/cpuinfo 2>/dev/null` in
-	  EV5)   UNAME_MACHINE=alphaev5 ;;
-	  EV56)  UNAME_MACHINE=alphaev56 ;;
-	  PCA56) UNAME_MACHINE=alphapca56 ;;
-	  PCA57) UNAME_MACHINE=alphapca56 ;;
-	  EV6)   UNAME_MACHINE=alphaev6 ;;
-	  EV67)  UNAME_MACHINE=alphaev67 ;;
-	  EV68*) UNAME_MACHINE=alphaev68 ;;
-	esac
-	objdump --private-headers /bin/sh | grep -q ld.so.1
-	if test "$?" = 0 ; then LIBC=gnulibc1 ; fi
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    arc:Linux:*:* | arceb:Linux:*:* | arc32:Linux:*:* | arc64:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    arm*:Linux:*:*)
-	set_cc_for_build
-	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
-	    | grep -q __ARM_EABI__
-	then
-	    GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	else
-	    if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
-		| grep -q __ARM_PCS_VFP
-	    then
-		GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabi
-	    else
-		GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabihf
-	    fi
-	fi
-	;;
-    avr32*:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    cris:Linux:*:*)
-	GUESS=$UNAME_MACHINE-axis-linux-$LIBC
-	;;
-    crisv32:Linux:*:*)
-	GUESS=$UNAME_MACHINE-axis-linux-$LIBC
-	;;
-    e2k:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    frv:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    hexagon:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    i*86:Linux:*:*)
-	GUESS=$UNAME_MACHINE-pc-linux-$LIBC
-	;;
-    ia64:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    k1om:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    kvx:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    kvx:cos:*:*)
-	GUESS=$UNAME_MACHINE-unknown-cos
-	;;
-    kvx:mbr:*:*)
-	GUESS=$UNAME_MACHINE-unknown-mbr
-	;;
-    loongarch32:Linux:*:* | loongarch64:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    m32r*:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    m68*:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    mips:Linux:*:* | mips64:Linux:*:*)
-	set_cc_for_build
-	IS_GLIBC=0
-	test x"${LIBC}" = xgnu && IS_GLIBC=1
-	sed 's/^	//' << EOF > "$dummy.c"
-	#undef CPU
-	#undef mips
-	#undef mipsel
-	#undef mips64
-	#undef mips64el
-	#if ${IS_GLIBC} && defined(_ABI64)
-	LIBCABI=gnuabi64
-	#else
-	#if ${IS_GLIBC} && defined(_ABIN32)
-	LIBCABI=gnuabin32
-	#else
-	LIBCABI=${LIBC}
-	#endif
-	#endif
-
-	#if ${IS_GLIBC} && defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6
-	CPU=mipsisa64r6
-	#else
-	#if ${IS_GLIBC} && !defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6
-	CPU=mipsisa32r6
-	#else
-	#if defined(__mips64)
-	CPU=mips64
-	#else
-	CPU=mips
-	#endif
-	#endif
-	#endif
-
-	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
-	MIPS_ENDIAN=el
-	#else
-	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
-	MIPS_ENDIAN=
-	#else
-	MIPS_ENDIAN=
-	#endif
-	#endif
-EOF
-	cc_set_vars=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU\|^MIPS_ENDIAN\|^LIBCABI'`
-	eval "$cc_set_vars"
-	test "x$CPU" != x && { echo "$CPU${MIPS_ENDIAN}-unknown-linux-$LIBCABI"; exit; }
-	;;
-    mips64el:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    openrisc*:Linux:*:*)
-	GUESS=or1k-unknown-linux-$LIBC
-	;;
-    or32:Linux:*:* | or1k*:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    padre:Linux:*:*)
-	GUESS=sparc-unknown-linux-$LIBC
-	;;
-    parisc64:Linux:*:* | hppa64:Linux:*:*)
-	GUESS=hppa64-unknown-linux-$LIBC
-	;;
-    parisc:Linux:*:* | hppa:Linux:*:*)
-	# Look for CPU level
-	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
-	  PA7*) GUESS=hppa1.1-unknown-linux-$LIBC ;;
-	  PA8*) GUESS=hppa2.0-unknown-linux-$LIBC ;;
-	  *)    GUESS=hppa-unknown-linux-$LIBC ;;
-	esac
-	;;
-    ppc64:Linux:*:*)
-	GUESS=powerpc64-unknown-linux-$LIBC
-	;;
-    ppc:Linux:*:*)
-	GUESS=powerpc-unknown-linux-$LIBC
-	;;
-    ppc64le:Linux:*:*)
-	GUESS=powerpc64le-unknown-linux-$LIBC
-	;;
-    ppcle:Linux:*:*)
-	GUESS=powerpcle-unknown-linux-$LIBC
-	;;
-    riscv32:Linux:*:* | riscv32be:Linux:*:* | riscv64:Linux:*:* | riscv64be:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    s390:Linux:*:* | s390x:Linux:*:*)
-	GUESS=$UNAME_MACHINE-ibm-linux-$LIBC
-	;;
-    sh64*:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    sh*:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    sparc:Linux:*:* | sparc64:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    tile*:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    vax:Linux:*:*)
-	GUESS=$UNAME_MACHINE-dec-linux-$LIBC
-	;;
-    x86_64:Linux:*:*)
-	set_cc_for_build
-	CPU=$UNAME_MACHINE
-	LIBCABI=$LIBC
-	if test "$CC_FOR_BUILD" != no_compiler_found; then
-	    ABI=64
-	    sed 's/^	    //' << EOF > "$dummy.c"
-	    #ifdef __i386__
-	    ABI=x86
-	    #else
-	    #ifdef __ILP32__
-	    ABI=x32
-	    #endif
-	    #endif
-EOF
-	    cc_set_abi=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^ABI' | sed 's, ,,g'`
-	    eval "$cc_set_abi"
-	    case $ABI in
-		x86) CPU=i686 ;;
-		x32) LIBCABI=${LIBC}x32 ;;
-	    esac
-	fi
-	GUESS=$CPU-pc-linux-$LIBCABI
-	;;
-    xtensa*:Linux:*:*)
-	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
-	;;
-    i*86:DYNIX/ptx:4*:*)
-	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
-	# earlier versions are messed up and put the nodename in both
-	# sysname and nodename.
-	GUESS=i386-sequent-sysv4
-	;;
-    i*86:UNIX_SV:4.2MP:2.*)
-	# Unixware is an offshoot of SVR4, but it has its own version
-	# number series starting with 2...
-	# I am not positive that other SVR4 systems won't match this,
-	# I just have to hope.  -- rms.
-	# Use sysv4.2uw... so that sysv4* matches it.
-	GUESS=$UNAME_MACHINE-pc-sysv4.2uw$UNAME_VERSION
-	;;
-    i*86:OS/2:*:*)
-	# If we were able to find 'uname', then EMX Unix compatibility
-	# is probably installed.
-	GUESS=$UNAME_MACHINE-pc-os2-emx
-	;;
-    i*86:XTS-300:*:STOP)
-	GUESS=$UNAME_MACHINE-unknown-stop
-	;;
-    i*86:atheos:*:*)
-	GUESS=$UNAME_MACHINE-unknown-atheos
-	;;
-    i*86:syllable:*:*)
-	GUESS=$UNAME_MACHINE-pc-syllable
-	;;
-    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
-	GUESS=i386-unknown-lynxos$UNAME_RELEASE
-	;;
-    i*86:*DOS:*:*)
-	GUESS=$UNAME_MACHINE-pc-msdosdjgpp
-	;;
-    i*86:*:4.*:*)
-	UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'`
-	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
-		GUESS=$UNAME_MACHINE-univel-sysv$UNAME_REL
-	else
-		GUESS=$UNAME_MACHINE-pc-sysv$UNAME_REL
-	fi
-	;;
-    i*86:*:5:[678]*)
-	# UnixWare 7.x, OpenUNIX and OpenServer 6.
-	case `/bin/uname -X | grep "^Machine"` in
-	    *486*)	     UNAME_MACHINE=i486 ;;
-	    *Pentium)	     UNAME_MACHINE=i586 ;;
-	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
-	esac
-	GUESS=$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
-	;;
-    i*86:*:3.2:*)
-	if test -f /usr/options/cb.name; then
-		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
-		GUESS=$UNAME_MACHINE-pc-isc$UNAME_REL
-	elif /bin/uname -X 2>/dev/null >/dev/null ; then
-		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
-		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
-		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
-			&& UNAME_MACHINE=i586
-		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
-			&& UNAME_MACHINE=i686
-		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
-			&& UNAME_MACHINE=i686
-		GUESS=$UNAME_MACHINE-pc-sco$UNAME_REL
-	else
-		GUESS=$UNAME_MACHINE-pc-sysv32
-	fi
-	;;
-    pc:*:*:*)
-	# Left here for compatibility:
-	# uname -m prints for DJGPP always 'pc', but it prints nothing about
-	# the processor, so we play safe by assuming i586.
-	# Note: whatever this is, it MUST be the same as what config.sub
-	# prints for the "djgpp" host, or else GDB configure will decide that
-	# this is a cross-build.
-	GUESS=i586-pc-msdosdjgpp
-	;;
-    Intel:Mach:3*:*)
-	GUESS=i386-pc-mach3
-	;;
-    paragon:*:*:*)
-	GUESS=i860-intel-osf1
-	;;
-    i860:*:4.*:*) # i860-SVR4
-	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
-	  GUESS=i860-stardent-sysv$UNAME_RELEASE    # Stardent Vistra i860-SVR4
-	else # Add other i860-SVR4 vendors below as they are discovered.
-	  GUESS=i860-unknown-sysv$UNAME_RELEASE     # Unknown i860-SVR4
-	fi
-	;;
-    mini*:CTIX:SYS*5:*)
-	# "miniframe"
-	GUESS=m68010-convergent-sysv
-	;;
-    mc68k:UNIX:SYSTEM5:3.51m)
-	GUESS=m68k-convergent-sysv
-	;;
-    M680?0:D-NIX:5.3:*)
-	GUESS=m68k-diab-dnix
-	;;
-    M68*:*:R3V[5678]*:*)
-	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
-    3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
-	OS_REL=''
-	test -r /etc/.relid \
-	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	  && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
-	  && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
-    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	  && { echo i486-ncr-sysv4; exit; } ;;
-    NCR*:*:4.2:* | MPRAS*:*:4.2:*)
-	OS_REL='.3'
-	test -r /etc/.relid \
-	    && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	    && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
-	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
-	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
-    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
-	GUESS=m68k-unknown-lynxos$UNAME_RELEASE
-	;;
-    mc68030:UNIX_System_V:4.*:*)
-	GUESS=m68k-atari-sysv4
-	;;
-    TSUNAMI:LynxOS:2.*:*)
-	GUESS=sparc-unknown-lynxos$UNAME_RELEASE
-	;;
-    rs6000:LynxOS:2.*:*)
-	GUESS=rs6000-unknown-lynxos$UNAME_RELEASE
-	;;
-    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
-	GUESS=powerpc-unknown-lynxos$UNAME_RELEASE
-	;;
-    SM[BE]S:UNIX_SV:*:*)
-	GUESS=mips-dde-sysv$UNAME_RELEASE
-	;;
-    RM*:ReliantUNIX-*:*:*)
-	GUESS=mips-sni-sysv4
-	;;
-    RM*:SINIX-*:*:*)
-	GUESS=mips-sni-sysv4
-	;;
-    *:SINIX-*:*:*)
-	if uname -p 2>/dev/null >/dev/null ; then
-		UNAME_MACHINE=`(uname -p) 2>/dev/null`
-		GUESS=$UNAME_MACHINE-sni-sysv4
-	else
-		GUESS=ns32k-sni-sysv
-	fi
-	;;
-    PENTIUM:*:4.0*:*)	# Unisys 'ClearPath HMP IX 4000' SVR4/MP effort
-			# says <Richard.M.Bartel@ccMail.Census.GOV>
-	GUESS=i586-unisys-sysv4
-	;;
-    *:UNIX_System_V:4*:FTX*)
-	# From Gerald Hewes <hewes@openmarket.com>.
-	# How about differentiating between stratus architectures? -djm
-	GUESS=hppa1.1-stratus-sysv4
-	;;
-    *:*:*:FTX*)
-	# From seanf@swdc.stratus.com.
-	GUESS=i860-stratus-sysv4
-	;;
-    i*86:VOS:*:*)
-	# From Paul.Green@stratus.com.
-	GUESS=$UNAME_MACHINE-stratus-vos
-	;;
-    *:VOS:*:*)
-	# From Paul.Green@stratus.com.
-	GUESS=hppa1.1-stratus-vos
-	;;
-    mc68*:A/UX:*:*)
-	GUESS=m68k-apple-aux$UNAME_RELEASE
-	;;
-    news*:NEWS-OS:6*:*)
-	GUESS=mips-sony-newsos6
-	;;
-    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
-	if test -d /usr/nec; then
-		GUESS=mips-nec-sysv$UNAME_RELEASE
-	else
-		GUESS=mips-unknown-sysv$UNAME_RELEASE
-	fi
-	;;
-    BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
-	GUESS=powerpc-be-beos
-	;;
-    BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
-	GUESS=powerpc-apple-beos
-	;;
-    BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
-	GUESS=i586-pc-beos
-	;;
-    BePC:Haiku:*:*)	# Haiku running on Intel PC compatible.
-	GUESS=i586-pc-haiku
-	;;
-    ppc:Haiku:*:*)	# Haiku running on Apple PowerPC
-	GUESS=powerpc-apple-haiku
-	;;
-    *:Haiku:*:*)	# Haiku modern gcc (not bound by BeOS compat)
-	GUESS=$UNAME_MACHINE-unknown-haiku
-	;;
-    SX-4:SUPER-UX:*:*)
-	GUESS=sx4-nec-superux$UNAME_RELEASE
-	;;
-    SX-5:SUPER-UX:*:*)
-	GUESS=sx5-nec-superux$UNAME_RELEASE
-	;;
-    SX-6:SUPER-UX:*:*)
-	GUESS=sx6-nec-superux$UNAME_RELEASE
-	;;
-    SX-7:SUPER-UX:*:*)
-	GUESS=sx7-nec-superux$UNAME_RELEASE
-	;;
-    SX-8:SUPER-UX:*:*)
-	GUESS=sx8-nec-superux$UNAME_RELEASE
-	;;
-    SX-8R:SUPER-UX:*:*)
-	GUESS=sx8r-nec-superux$UNAME_RELEASE
-	;;
-    SX-ACE:SUPER-UX:*:*)
-	GUESS=sxace-nec-superux$UNAME_RELEASE
-	;;
-    Power*:Rhapsody:*:*)
-	GUESS=powerpc-apple-rhapsody$UNAME_RELEASE
-	;;
-    *:Rhapsody:*:*)
-	GUESS=$UNAME_MACHINE-apple-rhapsody$UNAME_RELEASE
-	;;
-    arm64:Darwin:*:*)
-	GUESS=aarch64-apple-darwin$UNAME_RELEASE
-	;;
-    *:Darwin:*:*)
-	UNAME_PROCESSOR=`uname -p`
-	case $UNAME_PROCESSOR in
-	    unknown) UNAME_PROCESSOR=powerpc ;;
-	esac
-	if command -v xcode-select > /dev/null 2> /dev/null && \
-		! xcode-select --print-path > /dev/null 2> /dev/null ; then
-	    # Avoid executing cc if there is no toolchain installed as
-	    # cc will be a stub that puts up a graphical alert
-	    # prompting the user to install developer tools.
-	    CC_FOR_BUILD=no_compiler_found
-	else
-	    set_cc_for_build
-	fi
-	if test "$CC_FOR_BUILD" != no_compiler_found; then
-	    if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
-		   (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		   grep IS_64BIT_ARCH >/dev/null
-	    then
-		case $UNAME_PROCESSOR in
-		    i386) UNAME_PROCESSOR=x86_64 ;;
-		    powerpc) UNAME_PROCESSOR=powerpc64 ;;
-		esac
-	    fi
-	    # On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc
-	    if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \
-		   (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		   grep IS_PPC >/dev/null
-	    then
-		UNAME_PROCESSOR=powerpc
-	    fi
-	elif test "$UNAME_PROCESSOR" = i386 ; then
-	    # uname -m returns i386 or x86_64
-	    UNAME_PROCESSOR=$UNAME_MACHINE
-	fi
-	GUESS=$UNAME_PROCESSOR-apple-darwin$UNAME_RELEASE
-	;;
-    *:procnto*:*:* | *:QNX:[0123456789]*:*)
-	UNAME_PROCESSOR=`uname -p`
-	if test "$UNAME_PROCESSOR" = x86; then
-		UNAME_PROCESSOR=i386
-		UNAME_MACHINE=pc
-	fi
-	GUESS=$UNAME_PROCESSOR-$UNAME_MACHINE-nto-qnx$UNAME_RELEASE
-	;;
-    *:QNX:*:4*)
-	GUESS=i386-pc-qnx
-	;;
-    NEO-*:NONSTOP_KERNEL:*:*)
-	GUESS=neo-tandem-nsk$UNAME_RELEASE
-	;;
-    NSE-*:NONSTOP_KERNEL:*:*)
-	GUESS=nse-tandem-nsk$UNAME_RELEASE
-	;;
-    NSR-*:NONSTOP_KERNEL:*:*)
-	GUESS=nsr-tandem-nsk$UNAME_RELEASE
-	;;
-    NSV-*:NONSTOP_KERNEL:*:*)
-	GUESS=nsv-tandem-nsk$UNAME_RELEASE
-	;;
-    NSX-*:NONSTOP_KERNEL:*:*)
-	GUESS=nsx-tandem-nsk$UNAME_RELEASE
-	;;
-    *:NonStop-UX:*:*)
-	GUESS=mips-compaq-nonstopux
-	;;
-    BS2000:POSIX*:*:*)
-	GUESS=bs2000-siemens-sysv
-	;;
-    DS/*:UNIX_System_V:*:*)
-	GUESS=$UNAME_MACHINE-$UNAME_SYSTEM-$UNAME_RELEASE
-	;;
-    *:Plan9:*:*)
-	# "uname -m" is not consistent, so use $cputype instead. 386
-	# is converted to i386 for consistency with other x86
-	# operating systems.
-	if test "${cputype-}" = 386; then
-	    UNAME_MACHINE=i386
-	elif test "x${cputype-}" != x; then
-	    UNAME_MACHINE=$cputype
-	fi
-	GUESS=$UNAME_MACHINE-unknown-plan9
-	;;
-    *:TOPS-10:*:*)
-	GUESS=pdp10-unknown-tops10
-	;;
-    *:TENEX:*:*)
-	GUESS=pdp10-unknown-tenex
-	;;
-    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
-	GUESS=pdp10-dec-tops20
-	;;
-    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
-	GUESS=pdp10-xkl-tops20
-	;;
-    *:TOPS-20:*:*)
-	GUESS=pdp10-unknown-tops20
-	;;
-    *:ITS:*:*)
-	GUESS=pdp10-unknown-its
-	;;
-    SEI:*:*:SEIUX)
-	GUESS=mips-sei-seiux$UNAME_RELEASE
-	;;
-    *:DragonFly:*:*)
-	DRAGONFLY_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
-	GUESS=$UNAME_MACHINE-unknown-dragonfly$DRAGONFLY_REL
-	;;
-    *:*VMS:*:*)
-	UNAME_MACHINE=`(uname -p) 2>/dev/null`
-	case $UNAME_MACHINE in
-	    A*) GUESS=alpha-dec-vms ;;
-	    I*) GUESS=ia64-dec-vms ;;
-	    V*) GUESS=vax-dec-vms ;;
-	esac ;;
-    *:XENIX:*:SysV)
-	GUESS=i386-pc-xenix
-	;;
-    i*86:skyos:*:*)
-	SKYOS_REL=`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`
-	GUESS=$UNAME_MACHINE-pc-skyos$SKYOS_REL
-	;;
-    i*86:rdos:*:*)
-	GUESS=$UNAME_MACHINE-pc-rdos
-	;;
-    i*86:Fiwix:*:*)
-	GUESS=$UNAME_MACHINE-pc-fiwix
-	;;
-    *:AROS:*:*)
-	GUESS=$UNAME_MACHINE-unknown-aros
-	;;
-    x86_64:VMkernel:*:*)
-	GUESS=$UNAME_MACHINE-unknown-esx
-	;;
-    amd64:Isilon\ OneFS:*:*)
-	GUESS=x86_64-unknown-onefs
-	;;
-    *:Unleashed:*:*)
-	GUESS=$UNAME_MACHINE-unknown-unleashed$UNAME_RELEASE
-	;;
-    *:Ironclad:*:*)
-	GUESS=$UNAME_MACHINE-unknown-ironclad
-	;;
-esac
-
-# Do we have a guess based on uname results?
-if test "x$GUESS" != x; then
-    echo "$GUESS"
-    exit
-fi
-
-# No uname command or uname output not recognized.
-set_cc_for_build
-cat > "$dummy.c" <<EOF
-#ifdef _SEQUENT_
-#include <sys/types.h>
-#include <sys/utsname.h>
-#endif
-#if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__)
-#if defined (vax) || defined (__vax) || defined (__vax__) || defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__)
-#include <signal.h>
-#if defined(_SIZE_T_) || defined(SIGLOST)
-#include <sys/utsname.h>
-#endif
-#endif
-#endif
-int
-main ()
-{
-#if defined (sony)
-#if defined (MIPSEB)
-  /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,
-     I don't know....  */
-  printf ("mips-sony-bsd\n"); exit (0);
-#else
-#include <sys/param.h>
-  printf ("m68k-sony-newsos%s\n",
-#ifdef NEWSOS4
-  "4"
-#else
-  ""
-#endif
-  ); exit (0);
-#endif
-#endif
-
-#if defined (NeXT)
-#if !defined (__ARCHITECTURE__)
-#define __ARCHITECTURE__ "m68k"
-#endif
-  int version;
-  version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
-  if (version < 4)
-    printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
-  else
-    printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
-  exit (0);
-#endif
-
-#if defined (MULTIMAX) || defined (n16)
-#if defined (UMAXV)
-  printf ("ns32k-encore-sysv\n"); exit (0);
-#else
-#if defined (CMU)
-  printf ("ns32k-encore-mach\n"); exit (0);
-#else
-  printf ("ns32k-encore-bsd\n"); exit (0);
-#endif
-#endif
-#endif
-
-#if defined (__386BSD__)
-  printf ("i386-pc-bsd\n"); exit (0);
-#endif
-
-#if defined (sequent)
-#if defined (i386)
-  printf ("i386-sequent-dynix\n"); exit (0);
-#endif
-#if defined (ns32000)
-  printf ("ns32k-sequent-dynix\n"); exit (0);
-#endif
-#endif
-
-#if defined (_SEQUENT_)
-  struct utsname un;
-
-  uname(&un);
-  if (strncmp(un.version, "V2", 2) == 0) {
-    printf ("i386-sequent-ptx2\n"); exit (0);
-  }
-  if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
-    printf ("i386-sequent-ptx1\n"); exit (0);
-  }
-  printf ("i386-sequent-ptx\n"); exit (0);
-#endif
-
-#if defined (vax)
-#if !defined (ultrix)
-#include <sys/param.h>
-#if defined (BSD)
-#if BSD == 43
-  printf ("vax-dec-bsd4.3\n"); exit (0);
-#else
-#if BSD == 199006
-  printf ("vax-dec-bsd4.3reno\n"); exit (0);
-#else
-  printf ("vax-dec-bsd\n"); exit (0);
-#endif
-#endif
-#else
-  printf ("vax-dec-bsd\n"); exit (0);
-#endif
-#else
-#if defined(_SIZE_T_) || defined(SIGLOST)
-  struct utsname un;
-  uname (&un);
-  printf ("vax-dec-ultrix%s\n", un.release); exit (0);
-#else
-  printf ("vax-dec-ultrix\n"); exit (0);
-#endif
-#endif
-#endif
-#if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__)
-#if defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__)
-#if defined(_SIZE_T_) || defined(SIGLOST)
-  struct utsname *un;
-  uname (&un);
-  printf ("mips-dec-ultrix%s\n", un.release); exit (0);
-#else
-  printf ("mips-dec-ultrix\n"); exit (0);
-#endif
-#endif
-#endif
-
-#if defined (alliant) && defined (i860)
-  printf ("i860-alliant-bsd\n"); exit (0);
-#endif
-
-  exit (1);
-}
-EOF
-
-$CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null && SYSTEM_NAME=`"$dummy"` &&
-	{ echo "$SYSTEM_NAME"; exit; }
-
-# Apollos put the system type in the environment.
-test -d /usr/apollo && { echo "$ISP-apollo-$SYSTYPE"; exit; }
-
-echo "$0: unable to guess system type" >&2
-
-case $UNAME_MACHINE:$UNAME_SYSTEM in
-    mips:Linux | mips64:Linux)
-	# If we got here on MIPS GNU/Linux, output extra information.
-	cat >&2 <<EOF
-
-NOTE: MIPS GNU/Linux systems require a C compiler to fully recognize
-the system type. Please install a C compiler and try again.
-EOF
-	;;
-esac
-
-cat >&2 <<EOF
-
-This script (version $timestamp), has failed to recognize the
-operating system you are using. If your script is old, overwrite *all*
-copies of config.guess and config.sub with the latest versions from:
-
-  https://git.savannah.gnu.org/cgit/config.git/plain/config.guess
-and
-  https://git.savannah.gnu.org/cgit/config.git/plain/config.sub
-EOF
-
-our_year=`echo $timestamp | sed 's,-.*,,'`
-thisyear=`date +%Y`
-# shellcheck disable=SC2003
-script_age=`expr "$thisyear" - "$our_year"`
-if test "$script_age" -lt 3 ; then
-   cat >&2 <<EOF
-
-If $0 has already been updated, send the following data and any
-information you think might be pertinent to config-patches@gnu.org to
-provide the necessary information to handle your system.
-
-config.guess timestamp = $timestamp
-
-uname -m = `(uname -m) 2>/dev/null || echo unknown`
-uname -r = `(uname -r) 2>/dev/null || echo unknown`
-uname -s = `(uname -s) 2>/dev/null || echo unknown`
-uname -v = `(uname -v) 2>/dev/null || echo unknown`
-
-/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
-/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
-
-hostinfo               = `(hostinfo) 2>/dev/null`
-/bin/universe          = `(/bin/universe) 2>/dev/null`
-/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
-/bin/arch              = `(/bin/arch) 2>/dev/null`
-/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
-/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
-
-UNAME_MACHINE = "$UNAME_MACHINE"
-UNAME_RELEASE = "$UNAME_RELEASE"
-UNAME_SYSTEM  = "$UNAME_SYSTEM"
-UNAME_VERSION = "$UNAME_VERSION"
-EOF
-fi
-
-exit 1
-
-# Local variables:
-# eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-start: "timestamp='"
-# time-stamp-format: "%:y-%02m-%02d"
-# time-stamp-end: "'"
-# End:
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup-config.sub b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup-config.sub
deleted file mode 100644
index 4aaae46..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup-config.sub
+++ /dev/null
@@ -1,2354 +0,0 @@
-#! /bin/sh
-# Configuration validation subroutine script.
-#   Copyright 1992-2024 Free Software Foundation, Inc.
-
-# shellcheck disable=SC2006,SC2268,SC2162 # see below for rationale
-
-timestamp='2024-05-27'
-
-# This file is free software; you can redistribute it and/or modify it
-# under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, see <https://www.gnu.org/licenses/>.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that
-# program.  This Exception is an additional permission under section 7
-# of the GNU General Public License, version 3 ("GPLv3").
-
-
-# Please send patches to <config-patches@gnu.org>.
-#
-# Configuration subroutine to validate and canonicalize a configuration type.
-# Supply the specified configuration type as an argument.
-# If it is invalid, we print an error message on stderr and exit with code 1.
-# Otherwise, we print the canonical config type on stdout and succeed.
-
-# You can get the latest version of this script from:
-# https://git.savannah.gnu.org/cgit/config.git/plain/config.sub
-
-# This file is supposed to be the same for all GNU packages
-# and recognize all the CPU types, system types and aliases
-# that are meaningful with *any* GNU software.
-# Each package is responsible for reporting which valid configurations
-# it does not support.  The user should be able to distinguish
-# a failure to support a valid configuration from a meaningless
-# configuration.
-
-# The goal of this file is to map all the various variations of a given
-# machine specification into a single specification in the form:
-#	CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
-# or in some cases, the newer four-part form:
-#	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
-# It is wrong to echo any other type of specification.
-
-# The "shellcheck disable" line above the timestamp inhibits complaints
-# about features and limitations of the classic Bourne shell that were
-# superseded or lifted in POSIX.  However, this script identifies a wide
-# variety of pre-POSIX systems that do not have POSIX shells at all, and
-# even some reasonably current systems (Solaris 10 as case-in-point) still
-# have a pre-POSIX /bin/sh.
-
-me=`echo "$0" | sed -e 's,.*/,,'`
-
-usage="\
-Usage: $0 [OPTION] CPU-MFR-OPSYS or ALIAS
-
-Canonicalize a configuration name.
-
-Options:
-  -h, --help         print this help, then exit
-  -t, --time-stamp   print date of last modification, then exit
-  -v, --version      print version number, then exit
-
-Report bugs and patches to <config-patches@gnu.org>."
-
-version="\
-GNU config.sub ($timestamp)
-
-Copyright 1992-2024 Free Software Foundation, Inc.
-
-This is free software; see the source for copying conditions.  There is NO
-warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
-
-help="
-Try '$me --help' for more information."
-
-# Parse command line
-while test $# -gt 0 ; do
-  case $1 in
-    --time-stamp | --time* | -t )
-       echo "$timestamp" ; exit ;;
-    --version | -v )
-       echo "$version" ; exit ;;
-    --help | --h* | -h )
-       echo "$usage"; exit ;;
-    -- )     # Stop option processing
-       shift; break ;;
-    - )	# Use stdin as input.
-       break ;;
-    -* )
-       echo "$me: invalid option $1$help" >&2
-       exit 1 ;;
-
-    *local*)
-       # First pass through any local machine types.
-       echo "$1"
-       exit ;;
-
-    * )
-       break ;;
-  esac
-done
-
-case $# in
- 0) echo "$me: missing argument$help" >&2
-    exit 1;;
- 1) ;;
- *) echo "$me: too many arguments$help" >&2
-    exit 1;;
-esac
-
-# Split fields of configuration type
-saved_IFS=$IFS
-IFS="-" read field1 field2 field3 field4 <<EOF
-$1
-EOF
-IFS=$saved_IFS
-
-# Separate into logical components for further validation
-case $1 in
-	*-*-*-*-*)
-		echo "Invalid configuration '$1': more than four components" >&2
-		exit 1
-		;;
-	*-*-*-*)
-		basic_machine=$field1-$field2
-		basic_os=$field3-$field4
-		;;
-	*-*-*)
-		# Ambiguous whether COMPANY is present, or skipped and KERNEL-OS is two
-		# parts
-		maybe_os=$field2-$field3
-		case $maybe_os in
-			  cloudabi*-eabi* \
-			| kfreebsd*-gnu* \
-			| knetbsd*-gnu* \
-			| kopensolaris*-gnu* \
-			| linux-* \
-			| managarm-* \
-			| netbsd*-eabi* \
-			| netbsd*-gnu* \
-			| nto-qnx* \
-			| os2-emx* \
-			| rtmk-nova* \
-			| storm-chaos* \
-			| uclinux-gnu* \
-			| uclinux-uclibc* \
-			| windows-* )
-				basic_machine=$field1
-				basic_os=$maybe_os
-				;;
-			android-linux)
-				basic_machine=$field1-unknown
-				basic_os=linux-android
-				;;
-			*)
-				basic_machine=$field1-$field2
-				basic_os=$field3
-				;;
-		esac
-		;;
-	*-*)
-		case $field1-$field2 in
-			# Shorthands that happen to contain a single dash
-			convex-c[12] | convex-c3[248])
-				basic_machine=$field2-convex
-				basic_os=
-				;;
-			decstation-3100)
-				basic_machine=mips-dec
-				basic_os=
-				;;
-			*-*)
-				# Second component is usually, but not always the OS
-				case $field2 in
-					# Do not treat sunos as a manufacturer
-					sun*os*)
-						basic_machine=$field1
-						basic_os=$field2
-						;;
-					# Manufacturers
-					  3100* \
-					| 32* \
-					| 3300* \
-					| 3600* \
-					| 7300* \
-					| acorn \
-					| altos* \
-					| apollo \
-					| apple \
-					| atari \
-					| att* \
-					| axis \
-					| be \
-					| bull \
-					| cbm \
-					| ccur \
-					| cisco \
-					| commodore \
-					| convergent* \
-					| convex* \
-					| cray \
-					| crds \
-					| dec* \
-					| delta* \
-					| dg \
-					| digital \
-					| dolphin \
-					| encore* \
-					| gould \
-					| harris \
-					| highlevel \
-					| hitachi* \
-					| hp \
-					| ibm* \
-					| intergraph \
-					| isi* \
-					| knuth \
-					| masscomp \
-					| microblaze* \
-					| mips* \
-					| motorola* \
-					| ncr* \
-					| news \
-					| next \
-					| ns \
-					| oki \
-					| omron* \
-					| pc533* \
-					| rebel \
-					| rom68k \
-					| rombug \
-					| semi \
-					| sequent* \
-					| siemens \
-					| sgi* \
-					| siemens \
-					| sim \
-					| sni \
-					| sony* \
-					| stratus \
-					| sun \
-					| sun[234]* \
-					| tektronix \
-					| tti* \
-					| ultra \
-					| unicom* \
-					| wec \
-					| winbond \
-					| wrs)
-						basic_machine=$field1-$field2
-						basic_os=
-						;;
-					zephyr*)
-						basic_machine=$field1-unknown
-						basic_os=$field2
-						;;
-					*)
-						basic_machine=$field1
-						basic_os=$field2
-						;;
-				esac
-			;;
-		esac
-		;;
-	*)
-		# Convert single-component short-hands not valid as part of
-		# multi-component configurations.
-		case $field1 in
-			386bsd)
-				basic_machine=i386-pc
-				basic_os=bsd
-				;;
-			a29khif)
-				basic_machine=a29k-amd
-				basic_os=udi
-				;;
-			adobe68k)
-				basic_machine=m68010-adobe
-				basic_os=scout
-				;;
-			alliant)
-				basic_machine=fx80-alliant
-				basic_os=
-				;;
-			altos | altos3068)
-				basic_machine=m68k-altos
-				basic_os=
-				;;
-			am29k)
-				basic_machine=a29k-none
-				basic_os=bsd
-				;;
-			amdahl)
-				basic_machine=580-amdahl
-				basic_os=sysv
-				;;
-			amiga)
-				basic_machine=m68k-unknown
-				basic_os=
-				;;
-			amigaos | amigados)
-				basic_machine=m68k-unknown
-				basic_os=amigaos
-				;;
-			amigaunix | amix)
-				basic_machine=m68k-unknown
-				basic_os=sysv4
-				;;
-			apollo68)
-				basic_machine=m68k-apollo
-				basic_os=sysv
-				;;
-			apollo68bsd)
-				basic_machine=m68k-apollo
-				basic_os=bsd
-				;;
-			aros)
-				basic_machine=i386-pc
-				basic_os=aros
-				;;
-			aux)
-				basic_machine=m68k-apple
-				basic_os=aux
-				;;
-			balance)
-				basic_machine=ns32k-sequent
-				basic_os=dynix
-				;;
-			blackfin)
-				basic_machine=bfin-unknown
-				basic_os=linux
-				;;
-			cegcc)
-				basic_machine=arm-unknown
-				basic_os=cegcc
-				;;
-			cray)
-				basic_machine=j90-cray
-				basic_os=unicos
-				;;
-			crds | unos)
-				basic_machine=m68k-crds
-				basic_os=
-				;;
-			da30)
-				basic_machine=m68k-da30
-				basic_os=
-				;;
-			decstation | pmax | pmin | dec3100 | decstatn)
-				basic_machine=mips-dec
-				basic_os=
-				;;
-			delta88)
-				basic_machine=m88k-motorola
-				basic_os=sysv3
-				;;
-			dicos)
-				basic_machine=i686-pc
-				basic_os=dicos
-				;;
-			djgpp)
-				basic_machine=i586-pc
-				basic_os=msdosdjgpp
-				;;
-			ebmon29k)
-				basic_machine=a29k-amd
-				basic_os=ebmon
-				;;
-			es1800 | OSE68k | ose68k | ose | OSE)
-				basic_machine=m68k-ericsson
-				basic_os=ose
-				;;
-			gmicro)
-				basic_machine=tron-gmicro
-				basic_os=sysv
-				;;
-			go32)
-				basic_machine=i386-pc
-				basic_os=go32
-				;;
-			h8300hms)
-				basic_machine=h8300-hitachi
-				basic_os=hms
-				;;
-			h8300xray)
-				basic_machine=h8300-hitachi
-				basic_os=xray
-				;;
-			h8500hms)
-				basic_machine=h8500-hitachi
-				basic_os=hms
-				;;
-			harris)
-				basic_machine=m88k-harris
-				basic_os=sysv3
-				;;
-			hp300 | hp300hpux)
-				basic_machine=m68k-hp
-				basic_os=hpux
-				;;
-			hp300bsd)
-				basic_machine=m68k-hp
-				basic_os=bsd
-				;;
-			hppaosf)
-				basic_machine=hppa1.1-hp
-				basic_os=osf
-				;;
-			hppro)
-				basic_machine=hppa1.1-hp
-				basic_os=proelf
-				;;
-			i386mach)
-				basic_machine=i386-mach
-				basic_os=mach
-				;;
-			isi68 | isi)
-				basic_machine=m68k-isi
-				basic_os=sysv
-				;;
-			m68knommu)
-				basic_machine=m68k-unknown
-				basic_os=linux
-				;;
-			magnum | m3230)
-				basic_machine=mips-mips
-				basic_os=sysv
-				;;
-			merlin)
-				basic_machine=ns32k-utek
-				basic_os=sysv
-				;;
-			mingw64)
-				basic_machine=x86_64-pc
-				basic_os=mingw64
-				;;
-			mingw32)
-				basic_machine=i686-pc
-				basic_os=mingw32
-				;;
-			mingw32ce)
-				basic_machine=arm-unknown
-				basic_os=mingw32ce
-				;;
-			monitor)
-				basic_machine=m68k-rom68k
-				basic_os=coff
-				;;
-			morphos)
-				basic_machine=powerpc-unknown
-				basic_os=morphos
-				;;
-			moxiebox)
-				basic_machine=moxie-unknown
-				basic_os=moxiebox
-				;;
-			msdos)
-				basic_machine=i386-pc
-				basic_os=msdos
-				;;
-			msys)
-				basic_machine=i686-pc
-				basic_os=msys
-				;;
-			mvs)
-				basic_machine=i370-ibm
-				basic_os=mvs
-				;;
-			nacl)
-				basic_machine=le32-unknown
-				basic_os=nacl
-				;;
-			ncr3000)
-				basic_machine=i486-ncr
-				basic_os=sysv4
-				;;
-			netbsd386)
-				basic_machine=i386-pc
-				basic_os=netbsd
-				;;
-			netwinder)
-				basic_machine=armv4l-rebel
-				basic_os=linux
-				;;
-			news | news700 | news800 | news900)
-				basic_machine=m68k-sony
-				basic_os=newsos
-				;;
-			news1000)
-				basic_machine=m68030-sony
-				basic_os=newsos
-				;;
-			necv70)
-				basic_machine=v70-nec
-				basic_os=sysv
-				;;
-			nh3000)
-				basic_machine=m68k-harris
-				basic_os=cxux
-				;;
-			nh[45]000)
-				basic_machine=m88k-harris
-				basic_os=cxux
-				;;
-			nindy960)
-				basic_machine=i960-intel
-				basic_os=nindy
-				;;
-			mon960)
-				basic_machine=i960-intel
-				basic_os=mon960
-				;;
-			nonstopux)
-				basic_machine=mips-compaq
-				basic_os=nonstopux
-				;;
-			os400)
-				basic_machine=powerpc-ibm
-				basic_os=os400
-				;;
-			OSE68000 | ose68000)
-				basic_machine=m68000-ericsson
-				basic_os=ose
-				;;
-			os68k)
-				basic_machine=m68k-none
-				basic_os=os68k
-				;;
-			paragon)
-				basic_machine=i860-intel
-				basic_os=osf
-				;;
-			parisc)
-				basic_machine=hppa-unknown
-				basic_os=linux
-				;;
-			psp)
-				basic_machine=mipsallegrexel-sony
-				basic_os=psp
-				;;
-			pw32)
-				basic_machine=i586-unknown
-				basic_os=pw32
-				;;
-			rdos | rdos64)
-				basic_machine=x86_64-pc
-				basic_os=rdos
-				;;
-			rdos32)
-				basic_machine=i386-pc
-				basic_os=rdos
-				;;
-			rom68k)
-				basic_machine=m68k-rom68k
-				basic_os=coff
-				;;
-			sa29200)
-				basic_machine=a29k-amd
-				basic_os=udi
-				;;
-			sei)
-				basic_machine=mips-sei
-				basic_os=seiux
-				;;
-			sequent)
-				basic_machine=i386-sequent
-				basic_os=
-				;;
-			sps7)
-				basic_machine=m68k-bull
-				basic_os=sysv2
-				;;
-			st2000)
-				basic_machine=m68k-tandem
-				basic_os=
-				;;
-			stratus)
-				basic_machine=i860-stratus
-				basic_os=sysv4
-				;;
-			sun2)
-				basic_machine=m68000-sun
-				basic_os=
-				;;
-			sun2os3)
-				basic_machine=m68000-sun
-				basic_os=sunos3
-				;;
-			sun2os4)
-				basic_machine=m68000-sun
-				basic_os=sunos4
-				;;
-			sun3)
-				basic_machine=m68k-sun
-				basic_os=
-				;;
-			sun3os3)
-				basic_machine=m68k-sun
-				basic_os=sunos3
-				;;
-			sun3os4)
-				basic_machine=m68k-sun
-				basic_os=sunos4
-				;;
-			sun4)
-				basic_machine=sparc-sun
-				basic_os=
-				;;
-			sun4os3)
-				basic_machine=sparc-sun
-				basic_os=sunos3
-				;;
-			sun4os4)
-				basic_machine=sparc-sun
-				basic_os=sunos4
-				;;
-			sun4sol2)
-				basic_machine=sparc-sun
-				basic_os=solaris2
-				;;
-			sun386 | sun386i | roadrunner)
-				basic_machine=i386-sun
-				basic_os=
-				;;
-			sv1)
-				basic_machine=sv1-cray
-				basic_os=unicos
-				;;
-			symmetry)
-				basic_machine=i386-sequent
-				basic_os=dynix
-				;;
-			t3e)
-				basic_machine=alphaev5-cray
-				basic_os=unicos
-				;;
-			t90)
-				basic_machine=t90-cray
-				basic_os=unicos
-				;;
-			toad1)
-				basic_machine=pdp10-xkl
-				basic_os=tops20
-				;;
-			tpf)
-				basic_machine=s390x-ibm
-				basic_os=tpf
-				;;
-			udi29k)
-				basic_machine=a29k-amd
-				basic_os=udi
-				;;
-			ultra3)
-				basic_machine=a29k-nyu
-				basic_os=sym1
-				;;
-			v810 | necv810)
-				basic_machine=v810-nec
-				basic_os=none
-				;;
-			vaxv)
-				basic_machine=vax-dec
-				basic_os=sysv
-				;;
-			vms)
-				basic_machine=vax-dec
-				basic_os=vms
-				;;
-			vsta)
-				basic_machine=i386-pc
-				basic_os=vsta
-				;;
-			vxworks960)
-				basic_machine=i960-wrs
-				basic_os=vxworks
-				;;
-			vxworks68)
-				basic_machine=m68k-wrs
-				basic_os=vxworks
-				;;
-			vxworks29k)
-				basic_machine=a29k-wrs
-				basic_os=vxworks
-				;;
-			xbox)
-				basic_machine=i686-pc
-				basic_os=mingw32
-				;;
-			ymp)
-				basic_machine=ymp-cray
-				basic_os=unicos
-				;;
-			*)
-				basic_machine=$1
-				basic_os=
-				;;
-		esac
-		;;
-esac
-
-# Decode 1-component or ad-hoc basic machines
-case $basic_machine in
-	# Here we handle the default manufacturer of certain CPU types.  It is in
-	# some cases the only manufacturer, in others, it is the most popular.
-	w89k)
-		cpu=hppa1.1
-		vendor=winbond
-		;;
-	op50n)
-		cpu=hppa1.1
-		vendor=oki
-		;;
-	op60c)
-		cpu=hppa1.1
-		vendor=oki
-		;;
-	ibm*)
-		cpu=i370
-		vendor=ibm
-		;;
-	orion105)
-		cpu=clipper
-		vendor=highlevel
-		;;
-	mac | mpw | mac-mpw)
-		cpu=m68k
-		vendor=apple
-		;;
-	pmac | pmac-mpw)
-		cpu=powerpc
-		vendor=apple
-		;;
-
-	# Recognize the various machine names and aliases which stand
-	# for a CPU type and a company and sometimes even an OS.
-	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
-		cpu=m68000
-		vendor=att
-		;;
-	3b*)
-		cpu=we32k
-		vendor=att
-		;;
-	bluegene*)
-		cpu=powerpc
-		vendor=ibm
-		basic_os=cnk
-		;;
-	decsystem10* | dec10*)
-		cpu=pdp10
-		vendor=dec
-		basic_os=tops10
-		;;
-	decsystem20* | dec20*)
-		cpu=pdp10
-		vendor=dec
-		basic_os=tops20
-		;;
-	delta | 3300 | delta-motorola | 3300-motorola | motorola-delta | motorola-3300)
-		cpu=m68k
-		vendor=motorola
-		;;
-	# This used to be dpx2*, but that gets the RS6000-based
-	# DPX/20 and the x86-based DPX/2-100 wrong.  See
-	# https://oldskool.silicium.org/stations/bull_dpx20.htm
-	# https://www.feb-patrimoine.com/english/bull_dpx2.htm
-	# https://www.feb-patrimoine.com/english/unix_and_bull.htm
-	dpx2 | dpx2[23]00 | dpx2[23]xx)
-		cpu=m68k
-		vendor=bull
-		;;
-	dpx2100 | dpx21xx)
-		cpu=i386
-		vendor=bull
-		;;
-	dpx20)
-		cpu=rs6000
-		vendor=bull
-		;;
-	encore | umax | mmax)
-		cpu=ns32k
-		vendor=encore
-		;;
-	elxsi)
-		cpu=elxsi
-		vendor=elxsi
-		basic_os=${basic_os:-bsd}
-		;;
-	fx2800)
-		cpu=i860
-		vendor=alliant
-		;;
-	genix)
-		cpu=ns32k
-		vendor=ns
-		;;
-	h3050r* | hiux*)
-		cpu=hppa1.1
-		vendor=hitachi
-		basic_os=hiuxwe2
-		;;
-	hp3k9[0-9][0-9] | hp9[0-9][0-9])
-		cpu=hppa1.0
-		vendor=hp
-		;;
-	hp9k2[0-9][0-9] | hp9k31[0-9])
-		cpu=m68000
-		vendor=hp
-		;;
-	hp9k3[2-9][0-9])
-		cpu=m68k
-		vendor=hp
-		;;
-	hp9k6[0-9][0-9] | hp6[0-9][0-9])
-		cpu=hppa1.0
-		vendor=hp
-		;;
-	hp9k7[0-79][0-9] | hp7[0-79][0-9])
-		cpu=hppa1.1
-		vendor=hp
-		;;
-	hp9k78[0-9] | hp78[0-9])
-		# FIXME: really hppa2.0-hp
-		cpu=hppa1.1
-		vendor=hp
-		;;
-	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
-		# FIXME: really hppa2.0-hp
-		cpu=hppa1.1
-		vendor=hp
-		;;
-	hp9k8[0-9][13679] | hp8[0-9][13679])
-		cpu=hppa1.1
-		vendor=hp
-		;;
-	hp9k8[0-9][0-9] | hp8[0-9][0-9])
-		cpu=hppa1.0
-		vendor=hp
-		;;
-	i*86v32)
-		cpu=`echo "$1" | sed -e 's/86.*/86/'`
-		vendor=pc
-		basic_os=sysv32
-		;;
-	i*86v4*)
-		cpu=`echo "$1" | sed -e 's/86.*/86/'`
-		vendor=pc
-		basic_os=sysv4
-		;;
-	i*86v)
-		cpu=`echo "$1" | sed -e 's/86.*/86/'`
-		vendor=pc
-		basic_os=sysv
-		;;
-	i*86sol2)
-		cpu=`echo "$1" | sed -e 's/86.*/86/'`
-		vendor=pc
-		basic_os=solaris2
-		;;
-	j90 | j90-cray)
-		cpu=j90
-		vendor=cray
-		basic_os=${basic_os:-unicos}
-		;;
-	iris | iris4d)
-		cpu=mips
-		vendor=sgi
-		case $basic_os in
-		    irix*)
-			;;
-		    *)
-			basic_os=irix4
-			;;
-		esac
-		;;
-	miniframe)
-		cpu=m68000
-		vendor=convergent
-		;;
-	*mint | mint[0-9]* | *MiNT | *MiNT[0-9]*)
-		cpu=m68k
-		vendor=atari
-		basic_os=mint
-		;;
-	news-3600 | risc-news)
-		cpu=mips
-		vendor=sony
-		basic_os=newsos
-		;;
-	next | m*-next)
-		cpu=m68k
-		vendor=next
-		;;
-	np1)
-		cpu=np1
-		vendor=gould
-		;;
-	op50n-* | op60c-*)
-		cpu=hppa1.1
-		vendor=oki
-		basic_os=proelf
-		;;
-	pa-hitachi)
-		cpu=hppa1.1
-		vendor=hitachi
-		basic_os=hiuxwe2
-		;;
-	pbd)
-		cpu=sparc
-		vendor=tti
-		;;
-	pbb)
-		cpu=m68k
-		vendor=tti
-		;;
-	pc532)
-		cpu=ns32k
-		vendor=pc532
-		;;
-	pn)
-		cpu=pn
-		vendor=gould
-		;;
-	power)
-		cpu=power
-		vendor=ibm
-		;;
-	ps2)
-		cpu=i386
-		vendor=ibm
-		;;
-	rm[46]00)
-		cpu=mips
-		vendor=siemens
-		;;
-	rtpc | rtpc-*)
-		cpu=romp
-		vendor=ibm
-		;;
-	sde)
-		cpu=mipsisa32
-		vendor=sde
-		basic_os=${basic_os:-elf}
-		;;
-	simso-wrs)
-		cpu=sparclite
-		vendor=wrs
-		basic_os=vxworks
-		;;
-	tower | tower-32)
-		cpu=m68k
-		vendor=ncr
-		;;
-	vpp*|vx|vx-*)
-		cpu=f301
-		vendor=fujitsu
-		;;
-	w65)
-		cpu=w65
-		vendor=wdc
-		;;
-	w89k-*)
-		cpu=hppa1.1
-		vendor=winbond
-		basic_os=proelf
-		;;
-	none)
-		cpu=none
-		vendor=none
-		;;
-	leon|leon[3-9])
-		cpu=sparc
-		vendor=$basic_machine
-		;;
-	leon-*|leon[3-9]-*)
-		cpu=sparc
-		vendor=`echo "$basic_machine" | sed 's/-.*//'`
-		;;
-
-	*-*)
-		saved_IFS=$IFS
-		IFS="-" read cpu vendor <<EOF
-$basic_machine
-EOF
-		IFS=$saved_IFS
-		;;
-	# We use 'pc' rather than 'unknown'
-	# because (1) that's what they normally are, and
-	# (2) the word "unknown" tends to confuse beginning users.
-	i*86 | x86_64)
-		cpu=$basic_machine
-		vendor=pc
-		;;
-	# These rules are duplicated from below for sake of the special case above;
-	# i.e. things that normalized to x86 arches should also default to "pc"
-	pc98)
-		cpu=i386
-		vendor=pc
-		;;
-	x64 | amd64)
-		cpu=x86_64
-		vendor=pc
-		;;
-	# Recognize the basic CPU types without company name.
-	*)
-		cpu=$basic_machine
-		vendor=unknown
-		;;
-esac
-
-unset -v basic_machine
-
-# Decode basic machines in the full and proper CPU-Company form.
-case $cpu-$vendor in
-	# Here we handle the default manufacturer of certain CPU types in canonical form.
-	# It is in some cases the only manufacturer, in others, it is the most popular.
-	c[12]-convex | c[12]-unknown | c3[248]-convex | c3[248]-unknown)
-		vendor=convex
-		basic_os=${basic_os:-bsd}
-		;;
-	craynv-unknown)
-		vendor=cray
-		basic_os=${basic_os:-unicosmp}
-		;;
-	c90-unknown | c90-cray)
-		vendor=cray
-		basic_os=${basic_os:-unicos}
-		;;
-	fx80-unknown)
-		vendor=alliant
-		;;
-	romp-unknown)
-		vendor=ibm
-		;;
-	mmix-unknown)
-		vendor=knuth
-		;;
-	microblaze-unknown | microblazeel-unknown)
-		vendor=xilinx
-		;;
-	rs6000-unknown)
-		vendor=ibm
-		;;
-	vax-unknown)
-		vendor=dec
-		;;
-	pdp11-unknown)
-		vendor=dec
-		;;
-	we32k-unknown)
-		vendor=att
-		;;
-	cydra-unknown)
-		vendor=cydrome
-		;;
-	i370-ibm*)
-		vendor=ibm
-		;;
-	orion-unknown)
-		vendor=highlevel
-		;;
-	xps-unknown | xps100-unknown)
-		cpu=xps100
-		vendor=honeywell
-		;;
-
-	# Here we normalize CPU types with a missing or matching vendor
-	armh-unknown | armh-alt)
-		cpu=armv7l
-		vendor=alt
-		basic_os=${basic_os:-linux-gnueabihf}
-		;;
-
-	# Normalized CPU+vendor pairs that imply an OS, if not otherwise specified
-	m68k-isi)
-		basic_os=${basic_os:-sysv}
-		;;
-	m68k-sony)
-		basic_os=${basic_os:-newsos}
-		;;
-	m68k-tektronix)
-		basic_os=${basic_os:-bsd}
-		;;
-	m88k-harris)
-		basic_os=${basic_os:-sysv3}
-		;;
-	i386-bull | m68k-bull)
-		basic_os=${basic_os:-sysv3}
-		;;
-	rs6000-bull)
-		basic_os=${basic_os:-bosx}
-		;;
-	mips-sni)
-		basic_os=${basic_os:-sysv4}
-		;;
-
-	# Here we normalize CPU types irrespective of the vendor
-	amd64-*)
-		cpu=x86_64
-		;;
-	blackfin-*)
-		cpu=bfin
-		basic_os=${basic_os:-linux}
-		;;
-	c54x-*)
-		cpu=tic54x
-		;;
-	c55x-*)
-		cpu=tic55x
-		;;
-	c6x-*)
-		cpu=tic6x
-		;;
-	e500v[12]-*)
-		cpu=powerpc
-		basic_os=${basic_os}"spe"
-		;;
-	mips3*-*)
-		cpu=mips64
-		;;
-	ms1-*)
-		cpu=mt
-		;;
-	m68knommu-*)
-		cpu=m68k
-		basic_os=${basic_os:-linux}
-		;;
-	m9s12z-* | m68hcs12z-* | hcs12z-* | s12z-*)
-		cpu=s12z
-		;;
-	openrisc-*)
-		cpu=or32
-		;;
-	parisc-*)
-		cpu=hppa
-		basic_os=${basic_os:-linux}
-		;;
-	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
-		cpu=i586
-		;;
-	pentiumpro-* | p6-* | 6x86-* | athlon-* | athlon_*-*)
-		cpu=i686
-		;;
-	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
-		cpu=i686
-		;;
-	pentium4-*)
-		cpu=i786
-		;;
-	ppc-* | ppcbe-*)
-		cpu=powerpc
-		;;
-	ppcle-* | powerpclittle-*)
-		cpu=powerpcle
-		;;
-	ppc64-*)
-		cpu=powerpc64
-		;;
-	ppc64le-* | powerpc64little-*)
-		cpu=powerpc64le
-		;;
-	sb1-*)
-		cpu=mipsisa64sb1
-		;;
-	sb1el-*)
-		cpu=mipsisa64sb1el
-		;;
-	sh5e[lb]-*)
-		cpu=`echo "$cpu" | sed 's/^\(sh.\)e\(.\)$/\1\2e/'`
-		;;
-	spur-*)
-		cpu=spur
-		;;
-	strongarm-* | thumb-*)
-		cpu=arm
-		;;
-	tx39-*)
-		cpu=mipstx39
-		;;
-	tx39el-*)
-		cpu=mipstx39el
-		;;
-	xscale-* | xscalee[bl]-*)
-		cpu=`echo "$cpu" | sed 's/^xscale/arm/'`
-		;;
-	arm64-* | aarch64le-*)
-		cpu=aarch64
-		;;
-
-	# Recognize the canonical CPU Types that limit and/or modify the
-	# company names they are paired with.
-	cr16-*)
-		basic_os=${basic_os:-elf}
-		;;
-	crisv32-* | etraxfs*-*)
-		cpu=crisv32
-		vendor=axis
-		;;
-	cris-* | etrax*-*)
-		cpu=cris
-		vendor=axis
-		;;
-	crx-*)
-		basic_os=${basic_os:-elf}
-		;;
-	neo-tandem)
-		cpu=neo
-		vendor=tandem
-		;;
-	nse-tandem)
-		cpu=nse
-		vendor=tandem
-		;;
-	nsr-tandem)
-		cpu=nsr
-		vendor=tandem
-		;;
-	nsv-tandem)
-		cpu=nsv
-		vendor=tandem
-		;;
-	nsx-tandem)
-		cpu=nsx
-		vendor=tandem
-		;;
-	mipsallegrexel-sony)
-		cpu=mipsallegrexel
-		vendor=sony
-		;;
-	tile*-*)
-		basic_os=${basic_os:-linux-gnu}
-		;;
-
-	*)
-		# Recognize the canonical CPU types that are allowed with any
-		# company name.
-		case $cpu in
-			  1750a \
-			| 580 \
-			| [cjt]90 \
-			| a29k \
-			| aarch64 \
-			| aarch64_be \
-			| aarch64c \
-			| abacus \
-			| alpha \
-			| alpha64 \
-			| alpha64ev56 \
-			| alpha64ev6[78] \
-			| alpha64ev[4-8] \
-			| alpha64pca5[67] \
-			| alphaev56 \
-			| alphaev6[78] \
-			| alphaev[4-8] \
-			| alphapca5[67] \
-			| am33_2.0 \
-			| amdgcn \
-			| arc \
-			| arc32 \
-			| arc64 \
-			| arceb \
-			| arm \
-			| arm64e \
-			| arm64ec \
-			| arm[lb]e \
-			| arme[lb] \
-			| armv* \
-			| asmjs \
-			| avr \
-			| avr32 \
-			| ba \
-			| be32 \
-			| be64 \
-			| bfin \
-			| bpf \
-			| bs2000 \
-			| c30 \
-			| c4x \
-			| c8051 \
-			| c[123]* \
-			| clipper \
-			| craynv \
-			| csky \
-			| cydra \
-			| d10v \
-			| d30v \
-			| dlx \
-			| dsp16xx \
-			| e2k \
-			| elxsi \
-			| epiphany \
-			| f30[01] \
-			| f700 \
-			| fido \
-			| fr30 \
-			| frv \
-			| ft32 \
-			| fx80 \
-			| h8300 \
-			| h8500 \
-			| hexagon \
-			| hppa \
-			| hppa1.[01] \
-			| hppa2.0 \
-			| hppa2.0[nw] \
-			| hppa64 \
-			| i*86 \
-			| i370 \
-			| i860 \
-			| i960 \
-			| ia16 \
-			| ia64 \
-			| ip2k \
-			| iq2000 \
-			| javascript \
-			| k1om \
-			| kvx \
-			| le32 \
-			| le64 \
-			| lm32 \
-			| loongarch32 \
-			| loongarch64 \
-			| m32c \
-			| m32r \
-			| m32rle \
-			| m5200 \
-			| m68000 \
-			| m680[012346]0 \
-			| m6811 \
-			| m6812 \
-			| m68360 \
-			| m683?2 \
-			| m68hc11 \
-			| m68hc12 \
-			| m68hcs12x \
-			| m68k \
-			| m88110 \
-			| m88k \
-			| maxq \
-			| mb \
-			| mcore \
-			| mep \
-			| metag \
-			| microblaze \
-			| microblazeel \
-			| mips* \
-			| mmix \
-			| mn10200 \
-			| mn10300 \
-			| moxie \
-			| msp430 \
-			| mt \
-			| nanomips* \
-			| nds32 \
-			| nds32be \
-			| nds32le \
-			| nfp \
-			| nios \
-			| nios2 \
-			| nios2eb \
-			| nios2el \
-			| none \
-			| np1 \
-			| ns16k \
-			| ns32k \
-			| nvptx \
-			| open8 \
-			| or1k* \
-			| or32 \
-			| orion \
-			| pdp10 \
-			| pdp11 \
-			| picochip \
-			| pj \
-			| pjl \
-			| pn \
-			| power \
-			| powerpc \
-			| powerpc64 \
-			| powerpc64le \
-			| powerpcle \
-			| powerpcspe \
-			| pru \
-			| pyramid \
-			| riscv \
-			| riscv32 \
-			| riscv32be \
-			| riscv64 \
-			| riscv64be \
-			| rl78 \
-			| romp \
-			| rs6000 \
-			| rx \
-			| s390 \
-			| s390x \
-			| score \
-			| sh \
-			| sh64 \
-			| sh64le \
-			| sh[12345][lb]e \
-			| sh[1234] \
-			| sh[1234]e[lb] \
-			| sh[23]e \
-			| sh[23]ele \
-			| sh[24]a \
-			| sh[24]ae[lb] \
-			| sh[lb]e \
-			| she[lb] \
-			| shl \
-			| sparc \
-			| sparc64 \
-			| sparc64b \
-			| sparc64v \
-			| sparc86x \
-			| sparclet \
-			| sparclite \
-			| sparcv8 \
-			| sparcv9 \
-			| sparcv9b \
-			| sparcv9v \
-			| spu \
-			| sv1 \
-			| sx* \
-			| tahoe \
-			| thumbv7* \
-			| tic30 \
-			| tic4x \
-			| tic54x \
-			| tic55x \
-			| tic6x \
-			| tic80 \
-			| tron \
-			| ubicom32 \
-			| v70 \
-			| v810 \
-			| v850 \
-			| v850e \
-			| v850e1 \
-			| v850e2 \
-			| v850e2v3 \
-			| v850es \
-			| vax \
-			| vc4 \
-			| visium \
-			| w65 \
-			| wasm32 \
-			| wasm64 \
-			| we32k \
-			| x86 \
-			| x86_64 \
-			| xc16x \
-			| xgate \
-			| xps100 \
-			| xstormy16 \
-			| xtensa* \
-			| ymp \
-			| z80 \
-			| z8k)
-				;;
-
-			*)
-				echo "Invalid configuration '$1': machine '$cpu-$vendor' not recognized" 1>&2
-				exit 1
-				;;
-		esac
-		;;
-esac
-
-# Here we canonicalize certain aliases for manufacturers.
-case $vendor in
-	digital*)
-		vendor=dec
-		;;
-	commodore*)
-		vendor=cbm
-		;;
-	*)
-		;;
-esac
-
-# Decode manufacturer-specific aliases for certain operating systems.
-
-if test x"$basic_os" != x
-then
-
-# First recognize some ad-hoc cases, or perhaps split kernel-os, or else just
-# set os.
-obj=
-case $basic_os in
-	gnu/linux*)
-		kernel=linux
-		os=`echo "$basic_os" | sed -e 's|gnu/linux|gnu|'`
-		;;
-	os2-emx)
-		kernel=os2
-		os=`echo "$basic_os" | sed -e 's|os2-emx|emx|'`
-		;;
-	nto-qnx*)
-		kernel=nto
-		os=`echo "$basic_os" | sed -e 's|nto-qnx|qnx|'`
-		;;
-	*-*)
-		saved_IFS=$IFS
-		IFS="-" read kernel os <<EOF
-$basic_os
-EOF
-		IFS=$saved_IFS
-		;;
-	# Default OS when just kernel was specified
-	nto*)
-		kernel=nto
-		os=`echo "$basic_os" | sed -e 's|nto|qnx|'`
-		;;
-	linux*)
-		kernel=linux
-		os=`echo "$basic_os" | sed -e 's|linux|gnu|'`
-		;;
-	managarm*)
-		kernel=managarm
-		os=`echo "$basic_os" | sed -e 's|managarm|mlibc|'`
-		;;
-	*)
-		kernel=
-		os=$basic_os
-		;;
-esac
-
-# Now, normalize the OS (knowing we just have one component, it's not a kernel,
-# etc.)
-case $os in
-	# First match some system type aliases that might get confused
-	# with valid system types.
-	# solaris* is a basic system type, with this one exception.
-	auroraux)
-		os=auroraux
-		;;
-	bluegene*)
-		os=cnk
-		;;
-	solaris1 | solaris1.*)
-		os=`echo "$os" | sed -e 's|solaris1|sunos4|'`
-		;;
-	solaris)
-		os=solaris2
-		;;
-	unixware*)
-		os=sysv4.2uw
-		;;
-	# The marketing names for NeXT's operating systems were
-	# NeXTSTEP, NeXTSTEP 2, OpenSTEP 3, OpenSTEP 4.  'openstep' is
-	# mapped to 'openstep3', but 'openstep1' and 'openstep2' are
-	# mapped to 'nextstep' and 'nextstep2', consistent with the
-	# treatment of SunOS/Solaris.
-	ns | ns1 | nextstep | nextstep1 | openstep1)
-		os=nextstep
-		;;
-	ns2 | nextstep2 | openstep2)
-		os=nextstep2
-		;;
-	ns3 | nextstep3 | openstep | openstep3)
-		os=openstep3
-		;;
-	ns4 | nextstep4 | openstep4)
-		os=openstep4
-		;;
-	# es1800 is here to avoid being matched by es* (a different OS)
-	es1800*)
-		os=ose
-		;;
-	# Some version numbers need modification
-	chorusos*)
-		os=chorusos
-		;;
-	isc)
-		os=isc2.2
-		;;
-	sco6)
-		os=sco5v6
-		;;
-	sco5)
-		os=sco3.2v5
-		;;
-	sco4)
-		os=sco3.2v4
-		;;
-	sco3.2.[4-9]*)
-		os=`echo "$os" | sed -e 's/sco3.2./sco3.2v/'`
-		;;
-	sco*v* | scout)
-		# Don't match below
-		;;
-	sco*)
-		os=sco3.2v2
-		;;
-	psos*)
-		os=psos
-		;;
-	qnx*)
-		os=qnx
-		;;
-	hiux*)
-		os=hiuxwe2
-		;;
-	lynx*178)
-		os=lynxos178
-		;;
-	lynx*5)
-		os=lynxos5
-		;;
-	lynxos*)
-		# don't get caught up in next wildcard
-		;;
-	lynx*)
-		os=lynxos
-		;;
-	mac[0-9]*)
-		os=`echo "$os" | sed -e 's|mac|macos|'`
-		;;
-	opened*)
-		os=openedition
-		;;
-	os400*)
-		os=os400
-		;;
-	sunos5*)
-		os=`echo "$os" | sed -e 's|sunos5|solaris2|'`
-		;;
-	sunos6*)
-		os=`echo "$os" | sed -e 's|sunos6|solaris3|'`
-		;;
-	wince*)
-		os=wince
-		;;
-	utek*)
-		os=bsd
-		vendor=`echo "$vendor" | sed -e 's|^unknown$|tektronix|'`
-		;;
-	dynix*)
-		os=bsd
-		;;
-	acis*)
-		os=aos
-		;;
-	atheos*)
-		os=atheos
-		;;
-	syllable*)
-		os=syllable
-		;;
-	386bsd)
-		os=bsd
-		;;
-	ctix*)
-		os=sysv
-		vendor=`echo "$vendor" | sed -e 's|^unknown$|convergent|'`
-		;;
-	uts*)
-		os=sysv
-		;;
-	nova*)
-		kernel=rtmk
-		os=nova
-		;;
-	# Preserve the version number of sinix5.
-	sinix5.*)
-		os=`echo "$os" | sed -e 's|sinix|sysv|'`
-		vendor=`echo "$vendor" | sed -e 's|^unknown$|sni|'`
-		;;
-	sinix*)
-		os=sysv4
-		vendor=`echo "$vendor" | sed -e 's|^unknown$|sni|'`
-		;;
-	tpf*)
-		os=tpf
-		;;
-	triton*)
-		os=sysv3
-		;;
-	oss*)
-		os=sysv3
-		;;
-	svr4*)
-		os=sysv4
-		;;
-	svr3)
-		os=sysv3
-		;;
-	sysvr4)
-		os=sysv4
-		;;
-	ose*)
-		os=ose
-		;;
-	*mint | mint[0-9]* | *MiNT | MiNT[0-9]*)
-		os=mint
-		;;
-	dicos*)
-		os=dicos
-		;;
-	pikeos*)
-		# Until real need of OS specific support for
-		# particular features comes up, bare metal
-		# configurations are quite functional.
-		case $cpu in
-		    arm*)
-			os=eabi
-			;;
-		    *)
-			os=
-			obj=elf
-			;;
-		esac
-		;;
-	aout* | coff* | elf* | pe*)
-		# These are machine code file formats, not OSes
-		obj=$os
-		os=
-		;;
-	*)
-		# No normalization, but not necessarily accepted, that comes below.
-		;;
-esac
-
-else
-
-# Here we handle the default operating systems that come with various machines.
-# The value should be what the vendor currently ships out the door with their
-# machine or put another way, the most popular os provided with the machine.
-
-# Note that if you're going to try to match "-MANUFACTURER" here (say,
-# "-sun"), then you have to tell the case statement up towards the top
-# that MANUFACTURER isn't an operating system.  Otherwise, code above
-# will signal an error saying that MANUFACTURER isn't an operating
-# system, and we'll never get to this point.
-
-kernel=
-obj=
-case $cpu-$vendor in
-	score-*)
-		os=
-		obj=elf
-		;;
-	spu-*)
-		os=
-		obj=elf
-		;;
-	*-acorn)
-		os=riscix1.2
-		;;
-	arm*-rebel)
-		kernel=linux
-		os=gnu
-		;;
-	arm*-semi)
-		os=
-		obj=aout
-		;;
-	c4x-* | tic4x-*)
-		os=
-		obj=coff
-		;;
-	c8051-*)
-		os=
-		obj=elf
-		;;
-	clipper-intergraph)
-		os=clix
-		;;
-	hexagon-*)
-		os=
-		obj=elf
-		;;
-	tic54x-*)
-		os=
-		obj=coff
-		;;
-	tic55x-*)
-		os=
-		obj=coff
-		;;
-	tic6x-*)
-		os=
-		obj=coff
-		;;
-	# This must come before the *-dec entry.
-	pdp10-*)
-		os=tops20
-		;;
-	pdp11-*)
-		os=none
-		;;
-	*-dec | vax-*)
-		os=ultrix4.2
-		;;
-	m68*-apollo)
-		os=domain
-		;;
-	i386-sun)
-		os=sunos4.0.2
-		;;
-	m68000-sun)
-		os=sunos3
-		;;
-	m68*-cisco)
-		os=
-		obj=aout
-		;;
-	mep-*)
-		os=
-		obj=elf
-		;;
-	# The -sgi and -siemens entries must be before the mips- entry
-	# or we get the wrong os.
-	*-sgi)
-		os=irix
-		;;
-	*-siemens)
-		os=sysv4
-		;;
-	mips*-cisco)
-		os=
-		obj=elf
-		;;
-	mips*-*|nanomips*-*)
-		os=
-		obj=elf
-		;;
-	or32-*)
-		os=
-		obj=coff
-		;;
-	# This must be before the sparc-* entry or we get the wrong os.
-	*-tti)
-		os=sysv3
-		;;
-	sparc-* | *-sun)
-		os=sunos4.1.1
-		;;
-	pru-*)
-		os=
-		obj=elf
-		;;
-	*-be)
-		os=beos
-		;;
-	*-ibm)
-		os=aix
-		;;
-	*-knuth)
-		os=mmixware
-		;;
-	*-wec)
-		os=proelf
-		;;
-	*-winbond)
-		os=proelf
-		;;
-	*-oki)
-		os=proelf
-		;;
-	*-hp)
-		os=hpux
-		;;
-	*-hitachi)
-		os=hiuxwe2
-		;;
-	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
-		os=sysv
-		;;
-	*-cbm)
-		os=amigaos
-		;;
-	*-dg)
-		os=dgux
-		;;
-	*-dolphin)
-		os=sysv3
-		;;
-	m68k-ccur)
-		os=rtu
-		;;
-	m88k-omron*)
-		os=luna
-		;;
-	*-next)
-		os=nextstep
-		;;
-	*-sequent)
-		os=ptx
-		;;
-	*-crds)
-		os=unos
-		;;
-	*-ns)
-		os=genix
-		;;
-	i370-*)
-		os=mvs
-		;;
-	*-gould)
-		os=sysv
-		;;
-	*-highlevel)
-		os=bsd
-		;;
-	*-encore)
-		os=bsd
-		;;
-	*-masscomp)
-		os=rtu
-		;;
-	f30[01]-fujitsu | f700-fujitsu)
-		os=uxpv
-		;;
-	*-rom68k)
-		os=
-		obj=coff
-		;;
-	*-*bug)
-		os=
-		obj=coff
-		;;
-	*-apple)
-		os=macos
-		;;
-	*-atari*)
-		os=mint
-		;;
-	*-wrs)
-		os=vxworks
-		;;
-	*)
-		os=none
-		;;
-esac
-
-fi
-
-# Now, validate our (potentially fixed-up) individual pieces (OS, OBJ).
-
-case $os in
-	# Sometimes we do "kernel-libc", so those need to count as OSes.
-	llvm* | musl* | newlib* | relibc* | uclibc*)
-		;;
-	# Likewise for "kernel-abi"
-	eabi* | gnueabi*)
-		;;
-	# VxWorks passes extra cpu info in the 4th filed.
-	simlinux | simwindows | spe)
-		;;
-	# See `case $cpu-$os` validation below
-	ghcjs)
-		;;
-	# Now accept the basic system types.
-	# Each alternative MUST end in a * to match a version number.
-	  abug \
-	| aix* \
-	| amdhsa* \
-	| amigados* \
-	| amigaos* \
-	| android* \
-	| aof* \
-	| aos* \
-	| aros* \
-	| atheos* \
-	| auroraux* \
-	| aux* \
-	| beos* \
-	| bitrig* \
-	| bme* \
-	| bosx* \
-	| bsd* \
-	| cegcc* \
-	| chorusos* \
-	| chorusrdb* \
-	| clix* \
-	| cloudabi* \
-	| cnk* \
-	| conix* \
-	| cos* \
-	| cxux* \
-	| cygwin* \
-	| darwin* \
-	| dgux* \
-	| dicos* \
-	| dnix* \
-	| domain* \
-	| dragonfly* \
-	| drops* \
-	| ebmon* \
-	| ecoff* \
-	| ekkobsd* \
-	| emscripten* \
-	| emx* \
-	| es* \
-	| fiwix* \
-	| freebsd* \
-	| fuchsia* \
-	| genix* \
-	| genode* \
-	| glidix* \
-	| gnu* \
-	| go32* \
-	| haiku* \
-	| hcos* \
-	| hiux* \
-	| hms* \
-	| hpux* \
-	| ieee* \
-	| interix* \
-	| ios* \
-	| iris* \
-	| irix* \
-	| ironclad* \
-	| isc* \
-	| its* \
-	| l4re* \
-	| libertybsd* \
-	| lites* \
-	| lnews* \
-	| luna* \
-	| lynxos* \
-	| mach* \
-	| macos* \
-	| magic* \
-	| mbr* \
-	| midipix* \
-	| midnightbsd* \
-	| mingw32* \
-	| mingw64* \
-	| minix* \
-	| mint* \
-	| mirbsd* \
-	| mks* \
-	| mlibc* \
-	| mmixware* \
-	| mon960* \
-	| morphos* \
-	| moss* \
-	| moxiebox* \
-	| mpeix* \
-	| mpw* \
-	| msdos* \
-	| msys* \
-	| mvs* \
-	| nacl* \
-	| netbsd* \
-	| netware* \
-	| newsos* \
-	| nextstep* \
-	| nindy* \
-	| nonstopux* \
-	| nova* \
-	| nsk* \
-	| nucleus* \
-	| nx6 \
-	| nx7 \
-	| oabi* \
-	| ohos* \
-	| onefs* \
-	| openbsd* \
-	| openedition* \
-	| openstep* \
-	| os108* \
-	| os2* \
-	| os400* \
-	| os68k* \
-	| os9* \
-	| ose* \
-	| osf* \
-	| oskit* \
-	| osx* \
-	| palmos* \
-	| phoenix* \
-	| plan9* \
-	| powermax* \
-	| powerunix* \
-	| proelf* \
-	| psos* \
-	| psp* \
-	| ptx* \
-	| pw32* \
-	| qnx* \
-	| rdos* \
-	| redox* \
-	| rhapsody* \
-	| riscix* \
-	| riscos* \
-	| rtems* \
-	| rtmk* \
-	| rtu* \
-	| scout* \
-	| secbsd* \
-	| sei* \
-	| serenity* \
-	| sim* \
-	| skyos* \
-	| solaris* \
-	| solidbsd* \
-	| sortix* \
-	| storm-chaos* \
-	| sunos \
-	| sunos[34]* \
-	| superux* \
-	| syllable* \
-	| sym* \
-	| sysv* \
-	| tenex* \
-	| tirtos* \
-	| toppers* \
-	| tops10* \
-	| tops20* \
-	| tpf* \
-	| tvos* \
-	| twizzler* \
-	| uclinux* \
-	| udi* \
-	| udk* \
-	| ultrix* \
-	| unicos* \
-	| uniplus* \
-	| unleashed* \
-	| unos* \
-	| uwin* \
-	| uxpv* \
-	| v88r* \
-	|*vms* \
-	| vos* \
-	| vsta* \
-	| vxsim* \
-	| vxworks* \
-	| wasi* \
-	| watchos* \
-	| wince* \
-	| windiss* \
-	| windows* \
-	| winnt* \
-	| xenix* \
-	| xray* \
-	| zephyr* \
-	| zvmoe* )
-		;;
-	# This one is extra strict with allowed versions
-	sco3.2v2 | sco3.2v[4-9]* | sco5v6*)
-		# Don't forget version if it is 3.2v4 or newer.
-		;;
-	# This refers to builds using the UEFI calling convention
-	# (which depends on the architecture) and PE file format.
-	# Note that this is both a different calling convention and
-	# different file format than that of GNU-EFI
-	# (x86_64-w64-mingw32).
-	uefi)
-		;;
-	none)
-		;;
-	kernel* | msvc* )
-		# Restricted further below
-		;;
-	'')
-		if test x"$obj" = x
-		then
-			echo "Invalid configuration '$1': Blank OS only allowed with explicit machine code file format" 1>&2
-		fi
-		;;
-	*)
-		echo "Invalid configuration '$1': OS '$os' not recognized" 1>&2
-		exit 1
-		;;
-esac
-
-case $obj in
-	aout* | coff* | elf* | pe*)
-		;;
-	'')
-		# empty is fine
-		;;
-	*)
-		echo "Invalid configuration '$1': Machine code format '$obj' not recognized" 1>&2
-		exit 1
-		;;
-esac
-
-# Here we handle the constraint that a (synthetic) cpu and os are
-# valid only in combination with each other and nowhere else.
-case $cpu-$os in
-	# The "javascript-unknown-ghcjs" triple is used by GHC; we
-	# accept it here in order to tolerate that, but reject any
-	# variations.
-	javascript-ghcjs)
-		;;
-	javascript-* | *-ghcjs)
-		echo "Invalid configuration '$1': cpu '$cpu' is not valid with os '$os$obj'" 1>&2
-		exit 1
-		;;
-esac
-
-# As a final step for OS-related things, validate the OS-kernel combination
-# (given a valid OS), if there is a kernel.
-case $kernel-$os-$obj in
-	linux-gnu*- | linux-android*- | linux-dietlibc*- | linux-llvm*- \
-		    | linux-mlibc*- | linux-musl*- | linux-newlib*- \
-		    | linux-relibc*- | linux-uclibc*- | linux-ohos*- )
-		;;
-	uclinux-uclibc*- | uclinux-gnu*- )
-		;;
-	managarm-mlibc*- | managarm-kernel*- )
-		;;
-	windows*-msvc*-)
-		;;
-	-dietlibc*- | -llvm*- | -mlibc*- | -musl*- | -newlib*- | -relibc*- \
-		    | -uclibc*- )
-		# These are just libc implementations, not actual OSes, and thus
-		# require a kernel.
-		echo "Invalid configuration '$1': libc '$os' needs explicit kernel." 1>&2
-		exit 1
-		;;
-	-kernel*- )
-		echo "Invalid configuration '$1': '$os' needs explicit kernel." 1>&2
-		exit 1
-		;;
-	*-kernel*- )
-		echo "Invalid configuration '$1': '$kernel' does not support '$os'." 1>&2
-		exit 1
-		;;
-	*-msvc*- )
-		echo "Invalid configuration '$1': '$os' needs 'windows'." 1>&2
-		exit 1
-		;;
-	kfreebsd*-gnu*- | knetbsd*-gnu*- | netbsd*-gnu*- | kopensolaris*-gnu*-)
-		;;
-	vxworks-simlinux- | vxworks-simwindows- | vxworks-spe-)
-		;;
-	nto-qnx*-)
-		;;
-	os2-emx-)
-		;;
-	rtmk-nova-)
-		;;
-	*-eabi*- | *-gnueabi*-)
-		;;
-	none--*)
-		# None (no kernel, i.e. freestanding / bare metal),
-		# can be paired with an machine code file format
-		;;
-	-*-)
-		# Blank kernel with real OS is always fine.
-		;;
-	--*)
-		# Blank kernel and OS with real machine code file format is always fine.
-		;;
-	*-*-*)
-		echo "Invalid configuration '$1': Kernel '$kernel' not known to work with OS '$os'." 1>&2
-		exit 1
-		;;
-esac
-
-# Here we handle the case where we know the os, and the CPU type, but not the
-# manufacturer.  We pick the logical manufacturer.
-case $vendor in
-	unknown)
-		case $cpu-$os in
-			*-riscix*)
-				vendor=acorn
-				;;
-			*-sunos* | *-solaris*)
-				vendor=sun
-				;;
-			*-cnk* | *-aix*)
-				vendor=ibm
-				;;
-			*-beos*)
-				vendor=be
-				;;
-			*-hpux*)
-				vendor=hp
-				;;
-			*-mpeix*)
-				vendor=hp
-				;;
-			*-hiux*)
-				vendor=hitachi
-				;;
-			*-unos*)
-				vendor=crds
-				;;
-			*-dgux*)
-				vendor=dg
-				;;
-			*-luna*)
-				vendor=omron
-				;;
-			*-genix*)
-				vendor=ns
-				;;
-			*-clix*)
-				vendor=intergraph
-				;;
-			*-mvs* | *-opened*)
-				vendor=ibm
-				;;
-			*-os400*)
-				vendor=ibm
-				;;
-			s390-* | s390x-*)
-				vendor=ibm
-				;;
-			*-ptx*)
-				vendor=sequent
-				;;
-			*-tpf*)
-				vendor=ibm
-				;;
-			*-vxsim* | *-vxworks* | *-windiss*)
-				vendor=wrs
-				;;
-			*-aux*)
-				vendor=apple
-				;;
-			*-hms*)
-				vendor=hitachi
-				;;
-			*-mpw* | *-macos*)
-				vendor=apple
-				;;
-			*-*mint | *-mint[0-9]* | *-*MiNT | *-MiNT[0-9]*)
-				vendor=atari
-				;;
-			*-vos*)
-				vendor=stratus
-				;;
-		esac
-		;;
-esac
-
-echo "$cpu-$vendor${kernel:+-$kernel}${os:+-$os}${obj:+-$obj}"
-exit
-
-# Local variables:
-# eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-start: "timestamp='"
-# time-stamp-format: "%:y-%02m-%02d"
-# time-stamp-end: "'"
-# End:
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup-find-tclsh b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup-find-tclsh
deleted file mode 100644
index 9f6d6e9..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup-find-tclsh
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/bin/sh
-# Looks for a suitable tclsh or jimsh in the PATH
-# If not found, builds a bootstrap jimsh in current dir from source
-# Prefer $autosetup_tclsh if is set in the environment (unless ./jimsh0 works)
-# If an argument is given, use that as the test instead of autosetup-test-tclsh
-d="`dirname "$0"`"
-for tclsh in ./jimsh0 $autosetup_tclsh jimsh tclsh tclsh8.5 tclsh8.6 tclsh8.7; do
-	{ $tclsh "$d/${1-autosetup-test-tclsh}"; } 2>/dev/null && exit 0
-done
-echo 1>&2 "No installed jimsh or tclsh, building local bootstrap jimsh0"
-for cc in ${CC_FOR_BUILD:-cc} gcc; do
-	{ $cc -o jimsh0 "$d/jimsh0.c"; } 2>/dev/null >/dev/null || continue
-	./jimsh0 "$d/${1-autosetup-test-tclsh}" && exit 0
-done
-echo 1>&2 "No working C compiler found. Tried ${CC_FOR_BUILD:-cc} and gcc."
-echo false
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup-test-tclsh b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup-test-tclsh
deleted file mode 100644
index 75126d2..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/autosetup-test-tclsh
+++ /dev/null
@@ -1,20 +0,0 @@
-# A small Tcl script to verify that the chosen
-# interpreter works. Sometimes we might e.g. pick up
-# an interpreter for a different arch.
-# Outputs the full path to the interpreter
-
-if {[catch {info version} version] == 0} {
-	# This is Jim Tcl
-	if {$version >= 0.72} {
-		# Ensure that regexp works
-		regexp (a.*?) a
-		puts [info nameofexecutable]
-		exit 0
-	}
-} elseif {[catch {info tclversion} version] == 0} {
-	if {$version >= 8.5 && ![string match 8.5a* [info patchlevel]]} {
-		puts [info nameofexecutable]
-		exit 0
-	}
-}
-exit 1
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/cc-db.tcl b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/cc-db.tcl
deleted file mode 100644
index 12f1aed..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/cc-db.tcl
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright (c) 2011 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# @synopsis:
-#
-# The 'cc-db' module provides a knowledge-base of system idiosyncrasies.
-# In general, this module can always be included.
-
-use cc
-
-options {}
-
-# openbsd needs sys/types.h to detect some system headers
-cc-include-needs sys/socket.h sys/types.h
-cc-include-needs netinet/in.h sys/types.h
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/cc-lib.tcl b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/cc-lib.tcl
deleted file mode 100644
index 01a0fb3..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/cc-lib.tcl
+++ /dev/null
@@ -1,187 +0,0 @@
-# Copyright (c) 2011 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# @synopsis:
-#
-# Provides a library of common tests on top of the 'cc' module.
-
-use cc
-
-# @cc-check-lfs
-#
-# The equivalent of the 'AC_SYS_LARGEFILE' macro.
-#
-# defines 'HAVE_LFS' if LFS is available,
-# and defines '_FILE_OFFSET_BITS=64' if necessary
-#
-# Returns 1 if 'LFS' is available or 0 otherwise
-#
-proc cc-check-lfs {} {
-	cc-check-includes sys/types.h
-	msg-checking "Checking if -D_FILE_OFFSET_BITS=64 is needed..."
-	set lfs 1
-	if {[msg-quiet cc-with {-includes sys/types.h} {cc-check-sizeof off_t}] == 8} {
-		msg-result no
-	} elseif {[msg-quiet cc-with {-includes sys/types.h -cflags -D_FILE_OFFSET_BITS=64} {cc-check-sizeof off_t}] == 8} {
-		define _FILE_OFFSET_BITS 64
-		msg-result yes
-	} else {
-		set lfs 0
-		msg-result none
-	}
-	define-feature lfs $lfs
-	return $lfs
-}
-
-# @cc-check-endian
-#
-# The equivalent of the 'AC_C_BIGENDIAN' macro.
-#
-# defines 'HAVE_BIG_ENDIAN' if endian is known to be big,
-# or 'HAVE_LITTLE_ENDIAN' if endian is known to be little.
-#
-# Returns 1 if determined, or 0 if not.
-#
-proc cc-check-endian {} {
-	cc-check-includes sys/types.h sys/param.h
-	set rc 0
-	msg-checking "Checking endian..."
-	cc-with {-includes {sys/types.h sys/param.h}} {
-		if {[cctest -code {
-			#if !defined(BIG_ENDIAN) || !defined(BYTE_ORDER)
-				#error unknown
-			#elif BYTE_ORDER != BIG_ENDIAN
-				#error little
-			#endif
-		}]} {
-			define-feature big-endian
-			msg-result "big"
-			set rc 1
-		} elseif {[cctest -code {
-			#if !defined(LITTLE_ENDIAN) || !defined(BYTE_ORDER)
-				#error unknown
-			#elif BYTE_ORDER != LITTLE_ENDIAN
-				#error big
-			#endif
-		}]} {
-			define-feature little-endian
-			msg-result "little"
-			set rc 1
-		} else {
-			msg-result "unknown"
-		}
-	}
-	return $rc
-}
-
-# @cc-check-flags flag ?...?
-#
-# Checks whether the given C/C++ compiler flags can be used. Defines feature
-# names prefixed with 'HAVE_CFLAG' and 'HAVE_CXXFLAG' respectively, and
-# appends working flags to '-cflags' and 'AS_CFLAGS' or 'AS_CXXFLAGS'.
-proc cc-check-flags {args} {
-	set result 1
-	array set opts [cc-get-settings]
-	switch -exact -- $opts(-lang) {
-		c++ {
-			set lang C++
-			set prefix CXXFLAG
-		}
-		c {
-			set lang C
-			set prefix CFLAG
-		}
-		default {
-			autosetup-error "cc-check-flags failed with unknown language: $opts(-lang)"
-		}
-	}
-	foreach flag $args {
-		msg-checking "Checking whether the $lang compiler accepts $flag..."
-		if {[cctest -cflags $flag]} {
-			msg-result yes
-			define-feature $prefix$flag
-			cc-with [list -cflags [list $flag]]
-			define-append AS_${prefix}S $flag
-		} else {
-			msg-result no
-			set result 0
-		}
-	}
-	return $result
-}
-
-# @cc-check-standards ver ?...?
-#
-# Checks whether the C/C++ compiler accepts one of the specified '-std=$ver'
-# options, and appends the first working one to '-cflags' and 'AS_CFLAGS' or
-# 'AS_CXXFLAGS'.
-proc cc-check-standards {args} {
-	array set opts [cc-get-settings]
-	foreach std $args {
-		if {[cc-check-flags -std=$std]} {
-			return $std
-		}
-	}
-	return ""
-}
-
-# Checks whether $keyword is usable as alignof
-proc cctest_alignof {keyword} {
-	msg-checking "Checking for $keyword..."
-	if {[cctest -code "int x = ${keyword}(char), y = ${keyword}('x');"]} then {
-		msg-result ok
-		define-feature $keyword
-	} else {
-		msg-result "not found"
-	}
-}
-
-# @cc-check-c11
-#
-# Checks for several C11/C++11 extensions and their alternatives. Currently
-# checks for '_Static_assert', '_Alignof', '__alignof__', '__alignof'.
-proc cc-check-c11 {} {
-	msg-checking "Checking for _Static_assert..."
-	if {[cctest -code {
-		_Static_assert(1, "static assertions are available");
-	}]} then {
-		msg-result ok
-		define-feature _Static_assert
-	} else {
-		msg-result "not found"
-	}
-
-	cctest_alignof _Alignof
-	cctest_alignof __alignof__
-	cctest_alignof __alignof
-}
-
-# @cc-check-alloca
-#
-# The equivalent of the 'AC_FUNC_ALLOCA' macro.
-#
-# Checks for the existence of 'alloca'
-# defines 'HAVE_ALLOCA' and returns 1 if it exists.
-proc cc-check-alloca {} {
-	cc-check-some-feature alloca {
-		cctest -includes alloca.h -code { alloca (2 * sizeof (int)); }
-	}
-}
-
-# @cc-signal-return-type
-#
-# The equivalent of the 'AC_TYPE_SIGNAL' macro.
-#
-# defines 'RETSIGTYPE' to 'int' or 'void'.
-proc cc-signal-return-type {} {
-	msg-checking "Checking return type of signal handlers..."
-	cc-with {-includes {sys/types.h signal.h}} {
-		if {[cctest -code {return *(signal (0, 0)) (0) == 1;}]} {
-				set type int
-		} else {
-				set type void
-		}
-		define RETSIGTYPE $type
-		msg-result $type
-	}
-}
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/cc-shared.tcl b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/cc-shared.tcl
deleted file mode 100644
index 1fa200e..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/cc-shared.tcl
+++ /dev/null
@@ -1,115 +0,0 @@
-# Copyright (c) 2010 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# @synopsis:
-#
-# The 'cc-shared' module provides support for shared libraries and shared objects.
-# It defines the following variables:
-#
-## SH_CFLAGS         Flags to use compiling sources destined for a shared library
-## SH_LDFLAGS        Flags to use linking (creating) a shared library
-## SH_SOPREFIX       Prefix to use to set the soname when creating a shared library
-## SH_SOFULLPATH     Set to 1 if the shared library soname should include the full install path
-## SH_SOEXT          Extension for shared libs
-## SH_SOEXTVER       Format for versioned shared libs - %s = version
-## SHOBJ_CFLAGS      Flags to use compiling sources destined for a shared object
-## SHOBJ_LDFLAGS     Flags to use linking a shared object, undefined symbols allowed
-## SHOBJ_LDFLAGS_R   - as above, but all symbols must be resolved
-## SH_LINKRPATH      Format for setting the rpath when linking an executable, %s = path
-## SH_LINKFLAGS      Flags to use linking an executable which will load shared objects
-## LD_LIBRARY_PATH   Environment variable which specifies path to shared libraries
-## STRIPLIBFLAGS     Arguments to strip a dynamic library
-
-options {}
-
-# Defaults: gcc on unix
-define SHOBJ_CFLAGS -fPIC
-define SHOBJ_LDFLAGS -shared
-define SH_CFLAGS -fPIC
-define SH_LDFLAGS -shared
-define SH_LINKFLAGS -rdynamic
-define SH_LINKRPATH "-Wl,-rpath -Wl,%s"
-define SH_SOEXT .so
-define SH_SOEXTVER .so.%s
-define SH_SOPREFIX -Wl,-soname,
-define LD_LIBRARY_PATH LD_LIBRARY_PATH
-define STRIPLIBFLAGS --strip-unneeded
-
-# Note: This is a helpful reference for identifying the toolchain
-#       http://sourceforge.net/apps/mediawiki/predef/index.php?title=Compilers
-
-switch -glob -- [get-define host] {
-	*-*-darwin* {
-		define SHOBJ_CFLAGS "-dynamic -fno-common"
-		define SHOBJ_LDFLAGS "-bundle -undefined dynamic_lookup"
-		define SHOBJ_LDFLAGS_R -bundle
-		define SH_CFLAGS -dynamic
-		define SH_LDFLAGS -dynamiclib
-		define SH_LINKFLAGS ""
-		define SH_SOEXT .dylib
-		define SH_SOEXTVER .%s.dylib
-		define SH_SOPREFIX -Wl,-install_name,
-		define SH_SOFULLPATH
-		define LD_LIBRARY_PATH DYLD_LIBRARY_PATH
-		define STRIPLIBFLAGS -x
-	}
-	*-*-ming* - *-*-cygwin - *-*-msys {
-		define SHOBJ_CFLAGS ""
-		define SHOBJ_LDFLAGS -shared
-		define SH_CFLAGS ""
-		define SH_LDFLAGS -shared
-		define SH_LINKRPATH ""
-		define SH_LINKFLAGS ""
-		define SH_SOEXT .dll
-		define SH_SOEXTVER .dll
-		define SH_SOPREFIX ""
-		define LD_LIBRARY_PATH PATH
-	}
-	sparc* {
-		if {[msg-quiet cc-check-decls __SUNPRO_C]} {
-			msg-result "Found sun stdio compiler"
-			# sun stdio compiler
-			# XXX: These haven't been fully tested.
-			define SHOBJ_CFLAGS -KPIC
-			define SHOBJ_LDFLAGS "-G"
-			define SH_CFLAGS -KPIC
-			define SH_LINKFLAGS -Wl,-export-dynamic
-			define SH_SOPREFIX -Wl,-h,
-		}
-	}
-	*-*-solaris* {
-		if {[msg-quiet cc-check-decls __SUNPRO_C]} {
-			msg-result "Found sun stdio compiler"
-			# sun stdio compiler
-			# XXX: These haven't been fully tested.
-			define SHOBJ_CFLAGS -KPIC
-			define SHOBJ_LDFLAGS "-G"
-			define SH_CFLAGS -KPIC
-			define SH_LINKFLAGS -Wl,-export-dynamic
-			define SH_SOPREFIX -Wl,-h,
-		}
-	}
-	*-*-hpux* {
-		define SHOBJ_CFLAGS +z
-		define SHOBJ_LDFLAGS -b
-		define SH_CFLAGS +z
-		define SH_LDFLAGS -b
-		define SH_LINKFLAGS -Wl,+s
-		define SH_LINKRPATH "-Wl,+b -Wl,%s"
-		define SH_SOPREFIX -Wl,+h,
-		define STRIPLIBFLAGS -Wl,-s
-	}
-	*-*-haiku {
-		define SHOBJ_CFLAGS ""
-		define SHOBJ_LDFLAGS -shared
-		define SH_CFLAGS ""
-		define SH_LDFLAGS -shared
-		define SH_LINKFLAGS ""
-		define SH_SOPREFIX ""
-		define LD_LIBRARY_PATH LIBRARY_PATH
-	}
-}
-
-if {![is-defined SHOBJ_LDFLAGS_R]} {
-	define SHOBJ_LDFLAGS_R [get-define SHOBJ_LDFLAGS]
-}
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/cc.tcl b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/cc.tcl
deleted file mode 100644
index 05c1b1c..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/cc.tcl
+++ /dev/null
@@ -1,758 +0,0 @@
-# Copyright (c) 2010 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# @synopsis:
-#
-# The 'cc' module supports checking various 'features' of the C or C++
-# compiler/linker environment. Common commands are 'cc-check-includes',
-# 'cc-check-types', 'cc-check-functions', 'cc-with' and 'make-config-header'
-#
-# The following environment variables are used if set:
-#
-## CC       - C compiler
-## CXX      - C++ compiler
-## CPP      - C preprocessor
-## CCACHE   - Set to "none" to disable automatic use of ccache
-## CPPFLAGS  - Additional C preprocessor compiler flags (C and C++), before CFLAGS, CXXFLAGS
-## CFLAGS   - Additional C compiler flags
-## CXXFLAGS - Additional C++ compiler flags
-## LDFLAGS  - Additional compiler flags during linking
-## LINKFLAGS - ?How is this different from LDFLAGS?
-## LIBS     - Additional libraries to use (for all tests)
-## CROSS    - Tool prefix for cross compilation
-#
-# The following variables are defined from the corresponding
-# environment variables if set.
-#
-## CC_FOR_BUILD
-## LD
-
-use system
-
-options {}
-
-# Checks for the existence of the given function by linking
-#
-proc cctest_function {function} {
-	cctest -link 1 -declare "extern void $function\(void);" -code "$function\();"
-}
-
-# Checks for the existence of the given type by compiling
-proc cctest_type {type} {
-	cctest -code "$type _x;"
-}
-
-# Checks for the existence of the given type/structure member.
-# e.g. "struct stat.st_mtime"
-proc cctest_member {struct_member} {
-	# split at the first dot
-	regexp {^([^.]+)[.](.*)$} $struct_member -> struct member
-	cctest -code "static $struct _s; return sizeof(_s.$member);"
-}
-
-# Checks for the existence of the given define by compiling
-#
-proc cctest_define {name} {
-	cctest -code "#ifndef $name\n#error not defined\n#endif"
-}
-
-# Checks for the existence of the given name either as
-# a macro (#define) or an rvalue (such as an enum)
-#
-proc cctest_decl {name} {
-	cctest -code "#ifndef $name\n(void)$name;\n#endif"
-}
-
-# @cc-check-sizeof type ...
-#
-# Checks the size of the given types (between 1 and 32, inclusive).
-# Defines a variable with the size determined, or 'unknown' otherwise.
-# e.g. for type 'long long', defines 'SIZEOF_LONG_LONG'.
-# Returns the size of the last type.
-#
-proc cc-check-sizeof {args} {
-	foreach type $args {
-		msg-checking "Checking for sizeof $type..."
-		set size unknown
-		# Try the most common sizes first
-		foreach i {4 8 1 2 16 32} {
-			if {[cctest -code "static int _x\[sizeof($type) == $i ? 1 : -1\] = { 1 };"]} {
-				set size $i
-				break
-			}
-		}
-		msg-result $size
-		set define [feature-define-name $type SIZEOF_]
-		define $define $size
-	}
-	# Return the last result
-	get-define $define
-}
-
-# Checks for each feature in $list by using the given script.
-#
-# When the script is evaluated, $each is set to the feature
-# being checked, and $extra is set to any additional cctest args.
-#
-# Returns 1 if all features were found, or 0 otherwise.
-proc cc-check-some-feature {list script} {
-	set ret 1
-	foreach each $list {
-		if {![check-feature $each $script]} {
-			set ret 0
-		}
-	}
-	return $ret
-}
-
-# @cc-check-includes includes ...
-#
-# Checks that the given include files can be used.
-proc cc-check-includes {args} {
-	cc-check-some-feature $args {
-		set with {}
-		if {[dict exists $::autosetup(cc-include-deps) $each]} {
-			set deps [dict keys [dict get $::autosetup(cc-include-deps) $each]]
-			msg-quiet cc-check-includes {*}$deps
-			foreach i $deps {
-				if {[have-feature $i]} {
-					lappend with $i
-				}
-			}
-		}
-		if {[llength $with]} {
-			cc-with [list -includes $with] {
-				cctest -includes $each
-			}
-		} else {
-			cctest -includes $each
-		}
-	}
-}
-
-# @cc-include-needs include required ...
-#
-# Ensures that when checking for '$include', a check is first
-# made for each '$required' file, and if found, it is included with '#include'.
-proc cc-include-needs {file args} {
-	foreach depfile $args {
-		dict set ::autosetup(cc-include-deps) $file $depfile 1
-	}
-}
-
-# @cc-check-types type ...
-#
-# Checks that the types exist.
-proc cc-check-types {args} {
-	cc-check-some-feature $args {
-		cctest_type $each
-	}
-}
-
-# @cc-check-defines define ...
-#
-# Checks that the given preprocessor symbols are defined.
-proc cc-check-defines {args} {
-	cc-check-some-feature $args {
-		cctest_define $each
-	}
-}
-
-# @cc-check-decls name ...
-#
-# Checks that each given name is either a preprocessor symbol or rvalue
-# such as an enum. Note that the define used is 'HAVE_DECL_xxx'
-# rather than 'HAVE_xxx'.
-proc cc-check-decls {args} {
-	set ret 1
-	foreach name $args {
-		msg-checking "Checking for $name..."
-		set r [cctest_decl $name]
-		define-feature "decl $name" $r
-		if {$r} {
-			msg-result "ok"
-		} else {
-			msg-result "not found"
-			set ret 0
-		}
-	}
-	return $ret
-}
-
-# @cc-check-functions function ...
-#
-# Checks that the given functions exist (can be linked).
-proc cc-check-functions {args} {
-	cc-check-some-feature $args {
-		cctest_function $each
-	}
-}
-
-# @cc-check-members type.member ...
-#
-# Checks that the given type/structure members exist.
-# A structure member is of the form 'struct stat.st_mtime'.
-proc cc-check-members {args} {
-	cc-check-some-feature $args {
-		cctest_member $each
-	}
-}
-
-# @cc-check-function-in-lib function libs ?otherlibs?
-#
-# Checks that the given function can be found in one of the libs.
-#
-# First checks for no library required, then checks each of the libraries
-# in turn.
-#
-# If the function is found, the feature is defined and 'lib_$function' is defined
-# to '-l$lib' where the function was found, or "" if no library required.
-# In addition, '-l$lib' is prepended to the 'LIBS' define.
-#
-# If additional libraries may be needed for linking, they should be specified
-# with '$extralibs' as '-lotherlib1 -lotherlib2'.
-# These libraries are not automatically added to 'LIBS'.
-#
-# Returns 1 if found or 0 if not.
-#
-proc cc-check-function-in-lib {function libs {otherlibs {}}} {
-	msg-checking "Checking libs for $function..."
-	set found 0
-	cc-with [list -libs $otherlibs] {
-		if {[cctest_function $function]} {
-			msg-result "none needed"
-			define lib_$function ""
-			incr found
-		} else {
-			foreach lib $libs {
-				cc-with [list -libs -l$lib] {
-					if {[cctest_function $function]} {
-						msg-result -l$lib
-						define lib_$function -l$lib
-						# prepend to LIBS
-						define LIBS "-l$lib [get-define LIBS]"
-						incr found
-						break
-					}
-				}
-			}
-		}
-	}
-	define-feature $function $found
-	if {!$found} {
-		msg-result "no"
-	}
-	return $found
-}
-
-# @cc-check-tools tool ...
-#
-# Checks for existence of the given compiler tools, taking
-# into account any cross compilation prefix.
-#
-# For example, when checking for 'ar', first 'AR' is checked on the command
-# line and then in the environment. If not found, '${host}-ar' or
-# simply 'ar' is assumed depending upon whether cross compiling.
-# The path is searched for this executable, and if found 'AR' is defined
-# to the executable name.
-# Note that even when cross compiling, the simple 'ar' is used as a fallback,
-# but a warning is generated. This is necessary for some toolchains.
-#
-# It is an error if the executable is not found.
-#
-proc cc-check-tools {args} {
-	foreach tool $args {
-		set TOOL [string toupper $tool]
-		set exe [get-env $TOOL [get-define cross]$tool]
-		if {[find-executable $exe]} {
-			define $TOOL $exe
-			continue
-		}
-		if {[find-executable $tool]} {
-			msg-result "Warning: Failed to find $exe, falling back to $tool which may be incorrect"
-			define $TOOL $tool
-			continue
-		}
-		user-error "Failed to find $exe"
-	}
-}
-
-# @cc-check-progs prog ...
-#
-# Checks for existence of the given executables on the path.
-#
-# For example, when checking for 'grep', the path is searched for
-# the executable, 'grep', and if found 'GREP' is defined as 'grep'.
-#
-# If the executable is not found, the variable is defined as 'false'.
-# Returns 1 if all programs were found, or 0 otherwise.
-#
-proc cc-check-progs {args} {
-	set failed 0
-	foreach prog $args {
-		set PROG [string toupper $prog]
-		msg-checking "Checking for $prog..."
-		if {![find-executable $prog]} {
-			msg-result no
-			define $PROG false
-			incr failed
-		} else {
-			msg-result ok
-			define $PROG $prog
-		}
-	}
-	expr {!$failed}
-}
-
-# @cc-path-progs prog ...
-#
-# Like cc-check-progs, but sets the define to the full path rather
-# than just the program name.
-#
-proc cc-path-progs {args} {
-	set failed 0
-	foreach prog $args {
-		set PROG [string toupper $prog]
-		msg-checking "Checking for $prog..."
-		set path [find-executable-path $prog]
-		if {$path eq ""} {
-			msg-result no
-			define $PROG false
-			incr failed
-		} else {
-			msg-result $path
-			define $PROG $path
-		}
-	}
-	expr {!$failed}
-}
-
-# Adds the given settings to $::autosetup(ccsettings) and
-# returns the old settings.
-#
-proc cc-add-settings {settings} {
-	if {[llength $settings] % 2} {
-		autosetup-error "settings list is missing a value: $settings"
-	}
-
-	set prev [cc-get-settings]
-	# workaround a bug in some versions of jimsh by forcing
-	# conversion of $prev to a list
-	llength $prev
-
-	array set new $prev
-
-	foreach {name value} $settings {
-		switch -exact -- $name {
-			-cflags - -includes {
-				# These are given as lists
-				lappend new($name) {*}[list-non-empty $value]
-			}
-			-declare {
-				lappend new($name) $value
-			}
-			-libs {
-				# Note that new libraries are added before previous libraries
-				set new($name) [list {*}[list-non-empty $value] {*}$new($name)]
-			}
-			-link - -lang - -nooutput {
-				set new($name) $value
-			}
-			-source - -sourcefile - -code {
-				# XXX: These probably are only valid directly from cctest
-				set new($name) $value
-			}
-			default {
-				autosetup-error "unknown cctest setting: $name"
-			}
-		}
-	}
-
-	cc-store-settings [array get new]
-
-	return $prev
-}
-
-proc cc-store-settings {new} {
-	set ::autosetup(ccsettings) $new
-}
-
-proc cc-get-settings {} {
-	return $::autosetup(ccsettings)
-}
-
-# Similar to cc-add-settings, but each given setting
-# simply replaces the existing value.
-#
-# Returns the previous settings
-proc cc-update-settings {args} {
-	set prev [cc-get-settings]
-	cc-store-settings [dict merge $prev $args]
-	return $prev
-}
-
-# @cc-with settings ?{ script }?
-#
-# Sets the given 'cctest' settings and then runs the tests in '$script'.
-# Note that settings such as '-lang' replace the current setting, while
-# those such as '-includes' are appended to the existing setting.
-#
-# If no script is given, the settings become the default for the remainder
-# of the 'auto.def' file.
-#
-## cc-with {-lang c++} {
-##   # This will check with the C++ compiler
-##   cc-check-types bool
-##   cc-with {-includes signal.h} {
-##     # This will check with the C++ compiler, signal.h and any existing includes.
-##     ...
-##   }
-##   # back to just the C++ compiler
-## }
-#
-# The '-libs' setting is special in that newer values are added *before* earlier ones.
-#
-## cc-with {-libs {-lc -lm}} {
-##   cc-with {-libs -ldl} {
-##     cctest -libs -lsocket ...
-##     # libs will be in this order: -lsocket -ldl -lc -lm
-##   }
-## }
-#
-# If you wish to invoke something like cc-check-flags but not have -cflags updated,
-# use the following idiom:
-#
-## cc-with {} {
-##   cc-check-flags ...
-## }
-proc cc-with {settings args} {
-	if {[llength $args] == 0} {
-		cc-add-settings $settings
-	} elseif {[llength $args] > 1} {
-		autosetup-error "usage: cc-with settings ?script?"
-	} else {
-		set save [cc-add-settings $settings]
-		set rc [catch {uplevel 1 [lindex $args 0]} result info]
-		cc-store-settings $save
-		if {$rc != 0} {
-			return -code [dict get $info -code] $result
-		}
-		return $result
-	}
-}
-
-# @cctest ?settings?
-#
-# Low level C/C++ compiler checker. Compiles and or links a small C program
-# according to the arguments and returns 1 if OK, or 0 if not.
-#
-# Supported settings are:
-#
-## -cflags cflags      A list of flags to pass to the compiler
-## -includes list      A list of includes, e.g. {stdlib.h stdio.h}
-## -declare code       Code to declare before main()
-## -link 1             Don't just compile, link too
-## -lang c|c++         Use the C (default) or C++ compiler
-## -libs liblist       List of libraries to link, e.g. {-ldl -lm}
-## -code code          Code to compile in the body of main()
-## -source code        Compile a complete program. Ignore -includes, -declare and -code
-## -sourcefile file    Shorthand for -source [readfile [get-define srcdir]/$file]
-## -nooutput 1         Treat any compiler output (e.g. a warning) as an error
-#
-# Unless '-source' or '-sourcefile' is specified, the C program looks like:
-#
-## #include <firstinclude>   /* same for remaining includes in the list */
-## declare-code              /* any code in -declare, verbatim */
-## int main(void) {
-##   code                    /* any code in -code, verbatim */
-##   return 0;
-## }
-#
-# And the command line looks like:
-#
-## CC -cflags CFLAGS CPPFLAGS conftest.c -o conftest.o
-## CXX -cflags CXXFLAGS CPPFLAGS conftest.cpp -o conftest.o
-#
-# And if linking:
-#
-## CC LDFLAGS -cflags CFLAGS conftest.c -o conftest -libs LIBS
-## CXX LDFLAGS -cflags CXXFLAGS conftest.c -o conftest -libs LIBS
-#
-# Any failures are recorded in 'config.log'
-#
-proc cctest {args} {
-	set tmp conftest__
-
-	# Easiest way to merge in the settings
-	cc-with $args {
-		array set opts [cc-get-settings]
-	}
-
-	if {[info exists opts(-sourcefile)]} {
-		set opts(-source) [readfile [get-define srcdir]/$opts(-sourcefile) "#error can't find $opts(-sourcefile)"]
-	}
-	if {[info exists opts(-source)]} {
-		set lines $opts(-source)
-	} else {
-		foreach i $opts(-includes) {
-			if {$opts(-code) ne "" && ![feature-checked $i]} {
-				# Compiling real code with an unchecked header file
-				# Quickly (and silently) check for it now
-
-				# Remove all -includes from settings before checking
-				set saveopts [cc-update-settings -includes {}]
-				msg-quiet cc-check-includes $i
-				cc-store-settings $saveopts
-			}
-			if {$opts(-code) eq "" || [have-feature $i]} {
-				lappend source "#include <$i>"
-			}
-		}
-		lappend source {*}$opts(-declare)
-		lappend source "int main(void) {"
-		lappend source $opts(-code)
-		lappend source "return 0;"
-		lappend source "}"
-
-		set lines [join $source \n]
-	}
-
-	# Build the command line
-	set cmdline {}
-	lappend cmdline {*}[get-define CCACHE]
-	switch -exact -- $opts(-lang) {
-		c++ {
-			set src conftest__.cpp
-			lappend cmdline {*}[get-define CXX]
-			set cflags [get-define CXXFLAGS]
-		}
-		c {
-			set src conftest__.c
-			lappend cmdline {*}[get-define CC]
-			set cflags [get-define CFLAGS]
-		}
-		default {
-			autosetup-error "cctest called with unknown language: $opts(-lang)"
-		}
-	}
-
-	if {$opts(-link)} {
-		lappend cmdline {*}[get-define LDFLAGS]
-	} else {
-		lappend cflags {*}[get-define CPPFLAGS]
-		set tmp conftest__.o
-		lappend cmdline -c
-	}
-	lappend cmdline {*}$opts(-cflags) {*}[get-define cc-default-debug ""] {*}$cflags
-	lappend cmdline $src -o $tmp
-	if {$opts(-link)} {
-		lappend cmdline {*}$opts(-libs) {*}[get-define LIBS]
-	}
-
-	# At this point we have the complete command line and the
-	# complete source to be compiled. Get the result from cache if
-	# we can
-	if {[info exists ::cc_cache($cmdline,$lines)]} {
-		msg-checking "(cached) "
-		set ok $::cc_cache($cmdline,$lines)
-		if {$::autosetup(debug)} {
-			configlog "From cache (ok=$ok): [join $cmdline]"
-			configlog "============"
-			configlog $lines
-			configlog "============"
-		}
-		return $ok
-	}
-
-	writefile $src $lines\n
-
-	set ok 1
-	set err [catch {exec-with-stderr {*}$cmdline} result errinfo]
-	if {$err || ($opts(-nooutput) && [string length $result])} {
-		configlog "Failed: [join $cmdline]"
-		configlog $result
-		configlog "============"
-		configlog "The failed code was:"
-		configlog $lines
-		configlog "============"
-		set ok 0
-	} elseif {$::autosetup(debug)} {
-		configlog "Compiled OK: [join $cmdline]"
-		configlog "============"
-		configlog $lines
-		configlog "============"
-	}
-	file delete $src
-	file delete $tmp
-
-	# cache it
-	set ::cc_cache($cmdline,$lines) $ok
-
-	return $ok
-}
-
-# @make-autoconf-h outfile ?auto-patterns=HAVE_*? ?bare-patterns=SIZEOF_*?
-#
-# Deprecated - see 'make-config-header'
-proc make-autoconf-h {file {autopatterns {HAVE_*}} {barepatterns {SIZEOF_* HAVE_DECL_*}}} {
-	user-notice "*** make-autoconf-h is deprecated -- use make-config-header instead"
-	make-config-header $file -auto $autopatterns -bare $barepatterns
-}
-
-# @make-config-header outfile ?-auto patternlist? ?-bare patternlist? ?-none patternlist? ?-str patternlist? ...
-#
-# Examines all defined variables which match the given patterns
-# and writes an include file, '$file', which defines each of these.
-# Variables which match '-auto' are output as follows:
-# - defines which have the value '0' are ignored.
-# - defines which have integer values are defined as the integer value.
-# - any other value is defined as a string, e.g. '"value"'
-# Variables which match '-bare' are defined as-is.
-# Variables which match '-str' are defined as a string, e.g. '"value"'
-# Variables which match '-none' are omitted.
-#
-# Note that order is important. The first pattern that matches is selected.
-# Default behaviour is:
-#
-##  -bare {SIZEOF_* HAVE_DECL_*} -auto HAVE_* -none *
-#
-# If the file would be unchanged, it is not written.
-proc make-config-header {file args} {
-	set guard _[string toupper [regsub -all {[^a-zA-Z0-9]} [file tail $file] _]]
-	file mkdir [file dirname $file]
-	set lines {}
-	lappend lines "#ifndef $guard"
-	lappend lines "#define $guard"
-
-	# Add some defaults
-	lappend args -bare {SIZEOF_* HAVE_DECL_*} -auto HAVE_*
-
-	foreach n [lsort [dict keys [all-defines]]] {
-		set value [get-define $n]
-		set type [calc-define-output-type $n $args]
-		switch -exact -- $type {
-			-bare {
-				# Just output the value unchanged
-			}
-			-none {
-				continue
-			}
-			-str {
-				set value \"[string map [list \\ \\\\ \" \\\"] $value]\"
-			}
-			-auto {
-				# Automatically determine the type
-				if {$value eq "0"} {
-					lappend lines "/* #undef $n */"
-					continue
-				}
-				if {![string is integer -strict $value]} {
-					set value \"[string map [list \\ \\\\ \" \\\"] $value]\"
-				}
-			}
-			"" {
-				continue
-			}
-			default {
-				autosetup-error "Unknown type in make-config-header: $type"
-			}
-		}
-		lappend lines "#define $n $value"
-	}
-	lappend lines "#endif"
-	set buf [join $lines \n]
-	write-if-changed $file $buf {
-		msg-result "Created $file"
-	}
-}
-
-proc calc-define-output-type {name spec} {
-	foreach {type patterns} $spec {
-		foreach pattern $patterns {
-			if {[string match $pattern $name]} {
-				return $type
-			}
-		}
-	}
-	return ""
-}
-
-proc cc-init {} {
-	global autosetup
-
-	# Initialise some values from the environment or commandline or default settings
-	foreach i {LDFLAGS LIBS CPPFLAGS LINKFLAGS CFLAGS} {
-		lassign $i var default
-		define $var [get-env $var $default]
-	}
-
-	if {[env-is-set CC]} {
-		# Set by the user, so don't try anything else
-		set try [list [get-env CC ""]]
-	} else {
-		# Try some reasonable options
-		set try [list [get-define cross]cc [get-define cross]gcc]
-	}
-	define CC [find-an-executable {*}$try]
-	if {[get-define CC] eq ""} {
-		user-error "Could not find a C compiler. Tried: [join $try ", "]"
-	}
-
-	define CPP [get-env CPP "[get-define CC] -E"]
-
-	# XXX: Could avoid looking for a C++ compiler until requested
-	# If CXX isn't found, it is set to the empty string.
-	if {[env-is-set CXX]} {
-		define CXX [find-an-executable -required [get-env CXX ""]]
-	} else {
-		define CXX [find-an-executable [get-define cross]c++ [get-define cross]g++]
-	}
-
-	# CXXFLAGS default to CFLAGS if not specified
-	define CXXFLAGS [get-env CXXFLAGS [get-define CFLAGS]]
-
-	# May need a CC_FOR_BUILD, so look for one
-	define CC_FOR_BUILD [find-an-executable [get-env CC_FOR_BUILD ""] cc gcc false]
-
-	# These start empty and never come from the user or environment
-	define AS_CFLAGS ""
-	define AS_CPPFLAGS ""
-	define AS_CXXFLAGS ""
-
-	define CCACHE [find-an-executable [get-env CCACHE ccache]]
-
-	# If any of these are set in the environment, propagate them to the AUTOREMAKE commandline
-	foreach i {CC CXX CCACHE CPP CFLAGS CXXFLAGS CXXFLAGS LDFLAGS LIBS CROSS CPPFLAGS LINKFLAGS CC_FOR_BUILD LD} {
-		if {[env-is-set $i]} {
-			# Note: If the variable is set on the command line, get-env will return that value
-			# so the command line will continue to override the environment
-			define-append-argv AUTOREMAKE $i=[get-env $i ""]
-		}
-	}
-
-	# Initial cctest settings
-	cc-store-settings {-cflags {} -includes {} -declare {} -link 0 -lang c -libs {} -code {} -nooutput 0}
-	set autosetup(cc-include-deps) {}
-
-	msg-result "C compiler...[get-define CCACHE] [get-define CC] [get-define CFLAGS] [get-define CPPFLAGS]"
-	if {[get-define CXX] ne "false"} {
-		msg-result "C++ compiler...[get-define CCACHE] [get-define CXX] [get-define CXXFLAGS] [get-define CPPFLAGS]"
-	}
-	msg-result "Build C compiler...[get-define CC_FOR_BUILD]"
-
-	# On Darwin, we prefer to use -g0 to avoid creating .dSYM directories
-	# but some compilers may not support it, so test here.
-	switch -glob -- [get-define host] {
-		*-*-darwin* {
-			if {[cctest -cflags {-g0}]} {
-				define cc-default-debug -g0
-			}
-		}
-	}
-
-	if {![cc-check-includes stdlib.h]} {
-		user-error "Compiler does not work. See config.log"
-	}
-}
-
-cc-init
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/find_tclconfig.tcl b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/find_tclconfig.tcl
deleted file mode 100644
index c3d3df8..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/find_tclconfig.tcl
+++ /dev/null
@@ -1,24 +0,0 @@
-#
-# Run this TCL script to find and print the pathname for the tclConfig.sh
-# file.  Used by ../configure
-#
-if {[catch {
-  set libdir [tcl::pkgconfig get libdir,install]
-}]} {
-  puts stderr "tclsh too old:  does not support tcl::pkgconfig"
-  exit 1
-}
-if {![file exists $libdir]} {
-  puts stderr "tclsh reported library directory \"$libdir\" does not exist"
-  exit 1
-}
-if {![file exists $libdir/tclConfig.sh]} {
-  set n1 $libdir/tcl$::tcl_version
-  if {[file exists $n1/tclConfig.sh]} {
-    set libdir $n1
-  } else {
-    puts stderr "cannot find tclConfig.sh in either $libdir or $n1"
-    exit 1
-  }
-}
-puts $libdir
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/jimsh0.c b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/jimsh0.c
deleted file mode 100644
index 0f0a890..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/jimsh0.c
+++ /dev/null
@@ -1,24508 +0,0 @@
-/* This is single source file, bootstrap version of Jim Tcl. See http://jim.tcl.tk/ */
-#define JIM_COMPAT
-#define JIM_ANSIC
-#define JIM_REGEXP
-#define HAVE_NO_AUTOCONF
-#define JIM_TINY
-#define _JIMAUTOCONF_H
-#define TCL_LIBRARY "."
-#define jim_ext_bootstrap
-#define jim_ext_aio
-#define jim_ext_readdir
-#define jim_ext_regexp
-#define jim_ext_file
-#define jim_ext_glob
-#define jim_ext_exec
-#define jim_ext_clock
-#define jim_ext_array
-#define jim_ext_stdlib
-#define jim_ext_tclcompat
-#if defined(_MSC_VER)
-#define TCL_PLATFORM_OS "windows"
-#define TCL_PLATFORM_PLATFORM "windows"
-#define TCL_PLATFORM_PATH_SEPARATOR ";"
-#define HAVE_MKDIR_ONE_ARG
-#define HAVE_SYSTEM
-#elif defined(__MINGW32__)
-#define TCL_PLATFORM_OS "mingw"
-#define TCL_PLATFORM_PLATFORM "windows"
-#define TCL_PLATFORM_PATH_SEPARATOR ";"
-#define HAVE_MKDIR_ONE_ARG
-#define HAVE_SYSTEM
-#define HAVE_SYS_TIME_H
-#define HAVE_DIRENT_H
-#define HAVE_UNISTD_H
-#define HAVE_UMASK
-#include <sys/stat.h>
-#ifndef S_IRWXG
-#define S_IRWXG 0
-#endif
-#ifndef S_IRWXO
-#define S_IRWXO 0
-#endif
-#else
-#define TCL_PLATFORM_OS "unknown"
-#define TCL_PLATFORM_PLATFORM "unix"
-#define TCL_PLATFORM_PATH_SEPARATOR ":"
-#ifdef _MINIX
-#define vfork fork
-#define _POSIX_SOURCE
-#else
-#define _GNU_SOURCE
-#endif
-#define HAVE_FORK
-#define HAVE_WAITPID
-#define HAVE_ISATTY
-#define HAVE_MKSTEMP
-#define HAVE_LINK
-#define HAVE_SYS_TIME_H
-#define HAVE_DIRENT_H
-#define HAVE_UNISTD_H
-#define HAVE_UMASK
-#define HAVE_PIPE
-#define _FILE_OFFSET_BITS 64
-#endif
-#define JIM_VERSION 84
-#ifndef JIM_WIN32COMPAT_H
-#define JIM_WIN32COMPAT_H
-
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-#if defined(_WIN32) || defined(WIN32)
-
-#define HAVE_DLOPEN
-void *dlopen(const char *path, int mode);
-int dlclose(void *handle);
-void *dlsym(void *handle, const char *symbol);
-char *dlerror(void);
-
-
-#if defined(__MINGW32__)
-    #define JIM_SPRINTF_DOUBLE_NEEDS_FIX
-#endif
-
-#ifdef _MSC_VER
-
-
-#if _MSC_VER >= 1000
-	#pragma warning(disable:4146)
-#endif
-
-#include <limits.h>
-#define jim_wide _int64
-#ifndef HAVE_LONG_LONG
-#define HAVE_LONG_LONG
-#endif
-#ifndef LLONG_MAX
-	#define LLONG_MAX    9223372036854775807I64
-#endif
-#ifndef LLONG_MIN
-	#define LLONG_MIN    (-LLONG_MAX - 1I64)
-#endif
-#define JIM_WIDE_MIN LLONG_MIN
-#define JIM_WIDE_MAX LLONG_MAX
-#define JIM_WIDE_MODIFIER "I64d"
-#define strcasecmp _stricmp
-#define strtoull _strtoui64
-
-#include <io.h>
-
-#include <winsock.h>
-int gettimeofday(struct timeval *tv, void *unused);
-
-#define HAVE_OPENDIR
-struct dirent {
-	char *d_name;
-};
-
-typedef struct DIR {
-	long                handle;
-	struct _finddata_t  info;
-	struct dirent       result;
-	char                *name;
-} DIR;
-
-DIR *opendir(const char *name);
-int closedir(DIR *dir);
-struct dirent *readdir(DIR *dir);
-
-#endif
-
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-#ifndef UTF8_UTIL_H
-#define UTF8_UTIL_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-
-#define MAX_UTF8_LEN 4
-
-int utf8_fromunicode(char *p, unsigned uc);
-
-#ifndef JIM_UTF8
-#include <ctype.h>
-
-
-#define utf8_strlen(S, B) ((B) < 0 ? (int)strlen(S) : (B))
-#define utf8_strwidth(S, B) utf8_strlen((S), (B))
-#define utf8_tounicode(S, CP) (*(CP) = (unsigned char)*(S), 1)
-#define utf8_getchars(CP, C) (*(CP) = (C), 1)
-#define utf8_upper(C) toupper(C)
-#define utf8_title(C) toupper(C)
-#define utf8_lower(C) tolower(C)
-#define utf8_index(C, I) (I)
-#define utf8_charlen(C) 1
-#define utf8_prev_len(S, L) 1
-#define utf8_width(C) 1
-
-#else
-
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-#ifndef __JIM__H
-#define __JIM__H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <time.h>
-#include <limits.h>
-#include <stdlib.h>
-#include <stdarg.h>
-
-
-#ifndef HAVE_NO_AUTOCONF
-#endif
-
-
-
-#ifndef jim_wide
-#  ifdef HAVE_LONG_LONG
-#    define jim_wide long long
-#    ifndef LLONG_MAX
-#      define LLONG_MAX    9223372036854775807LL
-#    endif
-#    ifndef LLONG_MIN
-#      define LLONG_MIN    (-LLONG_MAX - 1LL)
-#    endif
-#    define JIM_WIDE_MIN LLONG_MIN
-#    define JIM_WIDE_MAX LLONG_MAX
-#  else
-#    define jim_wide long
-#    define JIM_WIDE_MIN LONG_MIN
-#    define JIM_WIDE_MAX LONG_MAX
-#  endif
-
-
-#  ifdef HAVE_LONG_LONG
-#    define JIM_WIDE_MODIFIER "lld"
-#  else
-#    define JIM_WIDE_MODIFIER "ld"
-#    define strtoull strtoul
-#  endif
-#endif
-
-#define UCHAR(c) ((unsigned char)(c))
-
-
-
-#define JIM_ABI_VERSION 101
-
-#define JIM_OK 0
-#define JIM_ERR 1
-#define JIM_RETURN 2
-#define JIM_BREAK 3
-#define JIM_CONTINUE 4
-#define JIM_SIGNAL 5
-#define JIM_EXIT 6
-
-#define JIM_EVAL 7
-
-#define JIM_MAX_CALLFRAME_DEPTH 1000
-#define JIM_MAX_EVAL_DEPTH 2000
-
-
-#define JIM_PRIV_FLAG_SHIFT 20
-
-#define JIM_NONE 0
-#define JIM_ERRMSG 1
-#define JIM_ENUM_ABBREV 2
-#define JIM_UNSHARED 4
-#define JIM_MUSTEXIST 8
-#define JIM_NORESULT 16
-
-
-#define JIM_SUBST_NOVAR 1
-#define JIM_SUBST_NOCMD 2
-#define JIM_SUBST_NOESC 4
-#define JIM_SUBST_FLAG 128
-
-
-#define JIM_CASESENS    0
-#define JIM_NOCASE      1
-#define JIM_OPT_END     2
-
-
-#define JIM_PATH_LEN 1024
-
-
-#define JIM_NOTUSED(V) ((void) V)
-
-#define JIM_LIBPATH "auto_path"
-#define JIM_INTERACTIVE "tcl_interactive"
-
-
-typedef struct Jim_Stack {
-    int len;
-    int maxlen;
-    void **vector;
-} Jim_Stack;
-
-
-typedef struct Jim_HashEntry {
-    void *key;
-    union {
-        void *val;
-        int intval;
-    } u;
-    struct Jim_HashEntry *next;
-} Jim_HashEntry;
-
-typedef struct Jim_HashTableType {
-    unsigned int (*hashFunction)(const void *key);
-    void *(*keyDup)(void *privdata, const void *key);
-    void *(*valDup)(void *privdata, const void *obj);
-    int (*keyCompare)(void *privdata, const void *key1, const void *key2);
-    void (*keyDestructor)(void *privdata, void *key);
-    void (*valDestructor)(void *privdata, void *obj);
-} Jim_HashTableType;
-
-typedef struct Jim_HashTable {
-    Jim_HashEntry **table;
-    const Jim_HashTableType *type;
-    void *privdata;
-    unsigned int size;
-    unsigned int sizemask;
-    unsigned int used;
-    unsigned int collisions;
-    unsigned int uniq;
-} Jim_HashTable;
-
-typedef struct Jim_HashTableIterator {
-    Jim_HashTable *ht;
-    Jim_HashEntry *entry, *nextEntry;
-    int index;
-} Jim_HashTableIterator;
-
-
-#define JIM_HT_INITIAL_SIZE     16
-
-
-#define Jim_FreeEntryVal(ht, entry) \
-    if ((ht)->type->valDestructor) \
-        (ht)->type->valDestructor((ht)->privdata, (entry)->u.val)
-
-#define Jim_SetHashVal(ht, entry, _val_) do { \
-    if ((ht)->type->valDup) \
-        (entry)->u.val = (ht)->type->valDup((ht)->privdata, (_val_)); \
-    else \
-        (entry)->u.val = (_val_); \
-} while(0)
-
-#define Jim_SetHashIntVal(ht, entry, _val_) (entry)->u.intval = (_val_)
-
-#define Jim_FreeEntryKey(ht, entry) \
-    if ((ht)->type->keyDestructor) \
-        (ht)->type->keyDestructor((ht)->privdata, (entry)->key)
-
-#define Jim_SetHashKey(ht, entry, _key_) do { \
-    if ((ht)->type->keyDup) \
-        (entry)->key = (ht)->type->keyDup((ht)->privdata, (_key_)); \
-    else \
-        (entry)->key = (void *)(_key_); \
-} while(0)
-
-#define Jim_CompareHashKeys(ht, key1, key2) \
-    (((ht)->type->keyCompare) ? \
-        (ht)->type->keyCompare((ht)->privdata, (key1), (key2)) : \
-        (key1) == (key2))
-
-#define Jim_HashKey(ht, key) ((ht)->type->hashFunction(key) + (ht)->uniq)
-
-#define Jim_GetHashEntryKey(he) ((he)->key)
-#define Jim_GetHashEntryVal(he) ((he)->u.val)
-#define Jim_GetHashEntryIntVal(he) ((he)->u.intval)
-#define Jim_GetHashTableCollisions(ht) ((ht)->collisions)
-#define Jim_GetHashTableSize(ht) ((ht)->size)
-#define Jim_GetHashTableUsed(ht) ((ht)->used)
-
-
-typedef struct Jim_Obj {
-    char *bytes;
-    const struct Jim_ObjType *typePtr;
-    int refCount;
-    int length;
-
-    union {
-
-        jim_wide wideValue;
-
-        int intValue;
-
-        double doubleValue;
-
-        void *ptr;
-
-        struct {
-            void *ptr1;
-            void *ptr2;
-        } twoPtrValue;
-
-        struct {
-            void *ptr;
-            int int1;
-            int int2;
-        } ptrIntValue;
-
-        struct {
-            struct Jim_VarVal *vv;
-            unsigned long callFrameId;
-            int global;
-        } varValue;
-
-        struct {
-            struct Jim_Obj *nsObj;
-            struct Jim_Cmd *cmdPtr;
-            unsigned long procEpoch;
-        } cmdValue;
-
-        struct {
-            struct Jim_Obj **ele;
-            int len;
-            int maxLen;
-        } listValue;
-
-        struct Jim_Dict *dictValue;
-
-        struct {
-            int maxLength;
-            int charLength;
-        } strValue;
-
-        struct {
-            unsigned long id;
-            struct Jim_Reference *refPtr;
-        } refValue;
-
-        struct {
-            struct Jim_Obj *fileNameObj;
-            int lineNumber;
-        } sourceValue;
-
-        struct {
-            struct Jim_Obj *varNameObjPtr;
-            struct Jim_Obj *indexObjPtr;
-        } dictSubstValue;
-        struct {
-            int line;
-            int argc;
-        } scriptLineValue;
-    } internalRep;
-    struct Jim_Obj *prevObjPtr;
-    struct Jim_Obj *nextObjPtr;
-} Jim_Obj;
-
-
-#define Jim_IncrRefCount(objPtr) \
-    ++(objPtr)->refCount
-#define Jim_DecrRefCount(interp, objPtr) \
-    if (--(objPtr)->refCount <= 0) Jim_FreeObj(interp, objPtr)
-#define Jim_IsShared(objPtr) \
-    ((objPtr)->refCount > 1)
-
-#define Jim_FreeNewObj Jim_FreeObj
-
-
-#define Jim_FreeIntRep(i,o) \
-    if ((o)->typePtr && (o)->typePtr->freeIntRepProc) \
-        (o)->typePtr->freeIntRepProc(i, o)
-
-
-#define Jim_GetIntRepPtr(o) (o)->internalRep.ptr
-
-
-#define Jim_SetIntRepPtr(o, p) \
-    (o)->internalRep.ptr = (p)
-
-
-struct Jim_Interp;
-
-typedef void (Jim_FreeInternalRepProc)(struct Jim_Interp *interp,
-        struct Jim_Obj *objPtr);
-typedef void (Jim_DupInternalRepProc)(struct Jim_Interp *interp,
-        struct Jim_Obj *srcPtr, Jim_Obj *dupPtr);
-typedef void (Jim_UpdateStringProc)(struct Jim_Obj *objPtr);
-
-typedef struct Jim_ObjType {
-    const char *name;
-    Jim_FreeInternalRepProc *freeIntRepProc;
-    Jim_DupInternalRepProc *dupIntRepProc;
-    Jim_UpdateStringProc *updateStringProc;
-    int flags;
-} Jim_ObjType;
-
-
-#define JIM_TYPE_NONE 0
-#define JIM_TYPE_REFERENCES 1
-
-
-
-typedef struct Jim_CallFrame {
-    unsigned long id;
-    int level;
-    struct Jim_HashTable vars;
-    struct Jim_HashTable *staticVars;
-    struct Jim_CallFrame *parent;
-    Jim_Obj *const *argv;
-    int argc;
-    Jim_Obj *procArgsObjPtr;
-    Jim_Obj *procBodyObjPtr;
-    struct Jim_CallFrame *next;
-    Jim_Obj *nsObj;
-    Jim_Obj *unused_fileNameObj;
-    int unused_line;
-    Jim_Stack *localCommands;
-    struct Jim_Obj *tailcallObj;
-    struct Jim_Cmd *tailcallCmd;
-} Jim_CallFrame;
-
-
-typedef struct Jim_EvalFrame {
-    Jim_CallFrame *framePtr;
-    int level;
-    int procLevel;
-    struct Jim_Cmd *cmd;
-    struct Jim_EvalFrame *parent;
-    Jim_Obj *const *argv;
-    int argc;
-    Jim_Obj *scriptObj;
-} Jim_EvalFrame;
-
-typedef struct Jim_VarVal {
-    Jim_Obj *objPtr;
-    struct Jim_CallFrame *linkFramePtr;
-    int refCount;
-} Jim_VarVal;
-
-
-typedef int Jim_CmdProc(struct Jim_Interp *interp, int argc,
-    Jim_Obj *const *argv);
-typedef void Jim_DelCmdProc(struct Jim_Interp *interp, void *privData);
-
-typedef struct Jim_Dict {
-    struct JimDictHashEntry {
-        int offset;
-        unsigned hash;
-    } *ht;
-    unsigned int size;
-    unsigned int sizemask;
-    unsigned int uniq;
-    Jim_Obj **table;
-    int len;
-    int maxLen;
-    unsigned int dummy;
-} Jim_Dict;
-
-typedef struct Jim_Cmd {
-    int inUse;
-    int isproc;
-    struct Jim_Cmd *prevCmd;
-    Jim_Obj *cmdNameObj;
-    union {
-        struct {
-
-            Jim_CmdProc *cmdProc;
-            Jim_DelCmdProc *delProc;
-            void *privData;
-        } native;
-        struct {
-
-            Jim_Obj *argListObjPtr;
-            Jim_Obj *bodyObjPtr;
-            Jim_HashTable *staticVars;
-            int argListLen;
-            int reqArity;
-            int optArity;
-            int argsPos;
-            int upcall;
-            struct Jim_ProcArg {
-                Jim_Obj *nameObjPtr;
-                Jim_Obj *defaultObjPtr;
-            } *arglist;
-            Jim_Obj *nsObj;
-        } proc;
-    } u;
-} Jim_Cmd;
-
-
-typedef struct Jim_PrngState {
-    unsigned char sbox[256];
-    unsigned int i, j;
-} Jim_PrngState;
-
-typedef struct Jim_Interp {
-    Jim_Obj *result;
-    int unused_errorLine;
-    Jim_Obj *currentFilenameObj;
-    int break_level;
-    int maxCallFrameDepth;
-    int maxEvalDepth;
-    int evalDepth;
-    int returnCode;
-    int returnLevel;
-    int exitCode;
-    long id;
-    int signal_level;
-    jim_wide sigmask;
-    int (*signal_set_result)(struct Jim_Interp *interp, jim_wide sigmask);
-    Jim_CallFrame *framePtr;
-    Jim_CallFrame *topFramePtr;
-    struct Jim_HashTable commands;
-    unsigned long procEpoch; /* Incremented every time the result
-                of procedures names lookup caching
-                may no longer be valid. */
-    unsigned long callFrameEpoch; /* Incremented every time a new
-                callframe is created. This id is used for the
-                'ID' field contained in the Jim_CallFrame
-                structure. */
-    int local;
-    int quitting;
-    int safeexpr;
-    Jim_Obj *liveList;
-    Jim_Obj *freeList;
-    Jim_Obj *unused_currentScriptObj;
-    Jim_EvalFrame topEvalFrame;
-    Jim_EvalFrame *evalFrame;
-    int procLevel;
-    Jim_Obj * const *unused_argv;
-    Jim_Obj *nullScriptObj;
-    Jim_Obj *emptyObj;
-    Jim_Obj *trueObj;
-    Jim_Obj *falseObj;
-    unsigned long referenceNextId;
-    struct Jim_HashTable references;
-    unsigned long lastCollectId; /* reference max Id of the last GC
-                execution. It's set to ~0 while the collection
-                is running as sentinel to avoid to recursive
-                calls via the [collect] command inside
-                finalizers. */
-    jim_wide lastCollectTime;
-    Jim_Obj *stackTrace;
-    Jim_Obj *errorProc;
-    Jim_Obj *unknown;
-    Jim_Obj *defer;
-    Jim_Obj *traceCmdObj;
-    int unknown_called;
-    int errorFlag;
-    void *cmdPrivData; /* Used to pass the private data pointer to
-                  a command. It is set to what the user specified
-                  via Jim_CreateCommand(). */
-
-    Jim_Cmd *oldCmdCache;
-    int oldCmdCacheSize;
-    struct Jim_CallFrame *freeFramesList;
-    struct Jim_HashTable assocData;
-    Jim_PrngState *prngState;
-    struct Jim_HashTable packages;
-    Jim_Stack *loadHandles;
-} Jim_Interp;
-
-#define Jim_SetResultString(i,s,l) Jim_SetResult(i, Jim_NewStringObj(i,s,l))
-#define Jim_SetResultInt(i,intval) Jim_SetResult(i, Jim_NewIntObj(i,intval))
-
-#define Jim_SetResultBool(i,b) Jim_SetResultInt(i, b)
-#define Jim_SetEmptyResult(i) Jim_SetResult(i, (i)->emptyObj)
-#define Jim_GetResult(i) ((i)->result)
-#define Jim_CmdPrivData(i) ((i)->cmdPrivData)
-
-#define Jim_SetResult(i,o) do {     \
-    Jim_Obj *_resultObjPtr_ = (o);    \
-    Jim_IncrRefCount(_resultObjPtr_); \
-    Jim_DecrRefCount(i,(i)->result);  \
-    (i)->result = _resultObjPtr_;     \
-} while(0)
-
-
-#define Jim_GetId(i) (++(i)->id)
-
-
-#define JIM_REFERENCE_TAGLEN 7 /* The tag is fixed-length, because the reference
-                                  string representation must be fixed length. */
-typedef struct Jim_Reference {
-    Jim_Obj *objPtr;
-    Jim_Obj *finalizerCmdNamePtr;
-    char tag[JIM_REFERENCE_TAGLEN+1];
-} Jim_Reference;
-
-
-#define Jim_NewEmptyStringObj(i) Jim_NewStringObj(i, "", 0)
-#define Jim_FreeHashTableIterator(iter) Jim_Free(iter)
-
-#define JIM_EXPORT extern
-
-
-
-JIM_EXPORT void *(*Jim_Allocator)(void *ptr, size_t size);
-
-#define Jim_Free(P) Jim_Allocator((P), 0)
-#define Jim_Realloc(P, S) Jim_Allocator((P), (S))
-#define Jim_Alloc(S) Jim_Allocator(NULL, (S))
-JIM_EXPORT char * Jim_StrDup (const char *s);
-JIM_EXPORT char *Jim_StrDupLen(const char *s, int l);
-
-
-JIM_EXPORT char **Jim_GetEnviron(void);
-JIM_EXPORT void Jim_SetEnviron(char **env);
-JIM_EXPORT int Jim_MakeTempFile(Jim_Interp *interp, const char *filename_template, int unlink_file);
-#ifndef CLOCK_REALTIME
-#  define CLOCK_REALTIME 0
-#endif
-#ifndef CLOCK_MONOTONIC
-#  define CLOCK_MONOTONIC 1
-#endif
-#ifndef CLOCK_MONOTONIC_RAW
-#  define CLOCK_MONOTONIC_RAW CLOCK_MONOTONIC
-#endif
-JIM_EXPORT jim_wide Jim_GetTimeUsec(unsigned type);
-
-
-JIM_EXPORT int Jim_Eval(Jim_Interp *interp, const char *script);
-
-
-JIM_EXPORT int Jim_EvalSource(Jim_Interp *interp, const char *filename, int lineno, const char *script);
-
-#define Jim_Eval_Named(I, S, F, L) Jim_EvalSource((I), (F), (L), (S))
-
-JIM_EXPORT int Jim_EvalGlobal(Jim_Interp *interp, const char *script);
-JIM_EXPORT int Jim_EvalFile(Jim_Interp *interp, const char *filename);
-JIM_EXPORT int Jim_EvalFileGlobal(Jim_Interp *interp, const char *filename);
-JIM_EXPORT int Jim_EvalObj (Jim_Interp *interp, Jim_Obj *scriptObjPtr);
-JIM_EXPORT int Jim_EvalObjVector (Jim_Interp *interp, int objc,
-        Jim_Obj *const *objv);
-JIM_EXPORT int Jim_EvalObjList(Jim_Interp *interp, Jim_Obj *listObj);
-JIM_EXPORT int Jim_EvalObjPrefix(Jim_Interp *interp, Jim_Obj *prefix,
-        int objc, Jim_Obj *const *objv);
-#define Jim_EvalPrefix(i, p, oc, ov) Jim_EvalObjPrefix((i), Jim_NewStringObj((i), (p), -1), (oc), (ov))
-JIM_EXPORT int Jim_EvalNamespace(Jim_Interp *interp, Jim_Obj *scriptObj, Jim_Obj *nsObj);
-JIM_EXPORT int Jim_SubstObj (Jim_Interp *interp, Jim_Obj *substObjPtr,
-        Jim_Obj **resObjPtrPtr, int flags);
-
-
-JIM_EXPORT Jim_Obj *Jim_GetSourceInfo(Jim_Interp *interp, Jim_Obj *objPtr,
-        int *lineptr);
-
-JIM_EXPORT void Jim_SetSourceInfo(Jim_Interp *interp, Jim_Obj *objPtr,
-        Jim_Obj *fileNameObj, int lineNumber);
-
-
-
-JIM_EXPORT void Jim_InitStack(Jim_Stack *stack);
-JIM_EXPORT void Jim_FreeStack(Jim_Stack *stack);
-JIM_EXPORT int Jim_StackLen(Jim_Stack *stack);
-JIM_EXPORT void Jim_StackPush(Jim_Stack *stack, void *element);
-JIM_EXPORT void * Jim_StackPop(Jim_Stack *stack);
-JIM_EXPORT void * Jim_StackPeek(Jim_Stack *stack);
-JIM_EXPORT void Jim_FreeStackElements(Jim_Stack *stack, void (*freeFunc)(void *ptr));
-
-
-JIM_EXPORT int Jim_InitHashTable (Jim_HashTable *ht,
-        const Jim_HashTableType *type, void *privdata);
-JIM_EXPORT void Jim_ExpandHashTable (Jim_HashTable *ht,
-        unsigned int size);
-JIM_EXPORT int Jim_AddHashEntry (Jim_HashTable *ht, const void *key,
-        void *val);
-JIM_EXPORT int Jim_ReplaceHashEntry (Jim_HashTable *ht,
-        const void *key, void *val);
-JIM_EXPORT int Jim_DeleteHashEntry (Jim_HashTable *ht,
-        const void *key);
-JIM_EXPORT int Jim_FreeHashTable (Jim_HashTable *ht);
-JIM_EXPORT Jim_HashEntry * Jim_FindHashEntry (Jim_HashTable *ht,
-        const void *key);
-JIM_EXPORT Jim_HashTableIterator *Jim_GetHashTableIterator
-        (Jim_HashTable *ht);
-JIM_EXPORT Jim_HashEntry * Jim_NextHashEntry
-        (Jim_HashTableIterator *iter);
-
-
-JIM_EXPORT Jim_Obj * Jim_NewObj (Jim_Interp *interp);
-JIM_EXPORT void Jim_FreeObj (Jim_Interp *interp, Jim_Obj *objPtr);
-JIM_EXPORT void Jim_InvalidateStringRep (Jim_Obj *objPtr);
-JIM_EXPORT Jim_Obj * Jim_DuplicateObj (Jim_Interp *interp,
-        Jim_Obj *objPtr);
-JIM_EXPORT const char * Jim_GetString(Jim_Obj *objPtr,
-        int *lenPtr);
-JIM_EXPORT const char *Jim_String(Jim_Obj *objPtr);
-JIM_EXPORT int Jim_Length(Jim_Obj *objPtr);
-
-
-JIM_EXPORT Jim_Obj * Jim_NewStringObj (Jim_Interp *interp,
-        const char *s, int len);
-JIM_EXPORT Jim_Obj *Jim_NewStringObjUtf8(Jim_Interp *interp,
-        const char *s, int charlen);
-JIM_EXPORT Jim_Obj * Jim_NewStringObjNoAlloc (Jim_Interp *interp,
-        char *s, int len);
-JIM_EXPORT void Jim_AppendString (Jim_Interp *interp, Jim_Obj *objPtr,
-        const char *str, int len);
-JIM_EXPORT void Jim_AppendObj (Jim_Interp *interp, Jim_Obj *objPtr,
-        Jim_Obj *appendObjPtr);
-JIM_EXPORT void Jim_AppendStrings (Jim_Interp *interp,
-        Jim_Obj *objPtr, ...);
-JIM_EXPORT int Jim_StringEqObj(Jim_Obj *aObjPtr, Jim_Obj *bObjPtr);
-JIM_EXPORT int Jim_StringMatchObj (Jim_Interp *interp, Jim_Obj *patternObjPtr,
-        Jim_Obj *objPtr, int nocase);
-JIM_EXPORT Jim_Obj * Jim_StringRangeObj (Jim_Interp *interp,
-        Jim_Obj *strObjPtr, Jim_Obj *firstObjPtr,
-        Jim_Obj *lastObjPtr);
-JIM_EXPORT Jim_Obj * Jim_FormatString (Jim_Interp *interp,
-        Jim_Obj *fmtObjPtr, int objc, Jim_Obj *const *objv);
-JIM_EXPORT Jim_Obj * Jim_ScanString (Jim_Interp *interp, Jim_Obj *strObjPtr,
-        Jim_Obj *fmtObjPtr, int flags);
-JIM_EXPORT int Jim_CompareStringImmediate (Jim_Interp *interp,
-        Jim_Obj *objPtr, const char *str);
-JIM_EXPORT int Jim_StringCompareObj(Jim_Interp *interp, Jim_Obj *firstObjPtr,
-        Jim_Obj *secondObjPtr, int nocase);
-JIM_EXPORT int Jim_Utf8Length(Jim_Interp *interp, Jim_Obj *objPtr);
-
-
-JIM_EXPORT Jim_Obj * Jim_NewReference (Jim_Interp *interp,
-        Jim_Obj *objPtr, Jim_Obj *tagPtr, Jim_Obj *cmdNamePtr);
-JIM_EXPORT Jim_Reference * Jim_GetReference (Jim_Interp *interp,
-        Jim_Obj *objPtr);
-JIM_EXPORT int Jim_SetFinalizer (Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *cmdNamePtr);
-JIM_EXPORT int Jim_GetFinalizer (Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj **cmdNamePtrPtr);
-
-
-JIM_EXPORT Jim_Interp * Jim_CreateInterp (void);
-JIM_EXPORT void Jim_FreeInterp (Jim_Interp *i);
-JIM_EXPORT int Jim_GetExitCode (Jim_Interp *interp);
-JIM_EXPORT const char *Jim_ReturnCode(int code);
-JIM_EXPORT void Jim_SetResultFormatted(Jim_Interp *interp, const char *format, ...);
-
-
-JIM_EXPORT void Jim_RegisterCoreCommands (Jim_Interp *interp);
-JIM_EXPORT int Jim_CreateCommand (Jim_Interp *interp,
-        const char *cmdName, Jim_CmdProc *cmdProc, void *privData,
-         Jim_DelCmdProc *delProc);
-JIM_EXPORT int Jim_DeleteCommand (Jim_Interp *interp,
-        Jim_Obj *cmdNameObj);
-JIM_EXPORT int Jim_RenameCommand (Jim_Interp *interp,
-        Jim_Obj *oldNameObj, Jim_Obj *newNameObj);
-JIM_EXPORT Jim_Cmd * Jim_GetCommand (Jim_Interp *interp,
-        Jim_Obj *objPtr, int flags);
-JIM_EXPORT int Jim_SetVariable (Jim_Interp *interp,
-        Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr);
-JIM_EXPORT int Jim_SetVariableStr (Jim_Interp *interp,
-        const char *name, Jim_Obj *objPtr);
-JIM_EXPORT int Jim_SetGlobalVariableStr (Jim_Interp *interp,
-        const char *name, Jim_Obj *objPtr);
-JIM_EXPORT int Jim_SetVariableStrWithStr (Jim_Interp *interp,
-        const char *name, const char *val);
-JIM_EXPORT int Jim_SetVariableLink (Jim_Interp *interp,
-        Jim_Obj *nameObjPtr, Jim_Obj *targetNameObjPtr,
-        Jim_CallFrame *targetCallFrame);
-JIM_EXPORT Jim_Obj * Jim_MakeGlobalNamespaceName(Jim_Interp *interp,
-        Jim_Obj *nameObjPtr);
-JIM_EXPORT Jim_Obj * Jim_GetVariable (Jim_Interp *interp,
-        Jim_Obj *nameObjPtr, int flags);
-JIM_EXPORT Jim_Obj * Jim_GetGlobalVariable (Jim_Interp *interp,
-        Jim_Obj *nameObjPtr, int flags);
-JIM_EXPORT Jim_Obj * Jim_GetVariableStr (Jim_Interp *interp,
-        const char *name, int flags);
-JIM_EXPORT Jim_Obj * Jim_GetGlobalVariableStr (Jim_Interp *interp,
-        const char *name, int flags);
-JIM_EXPORT int Jim_UnsetVariable (Jim_Interp *interp,
-        Jim_Obj *nameObjPtr, int flags);
-
-
-JIM_EXPORT Jim_CallFrame *Jim_GetCallFrameByLevel(Jim_Interp *interp,
-        Jim_Obj *levelObjPtr);
-
-
-JIM_EXPORT int Jim_Collect (Jim_Interp *interp);
-JIM_EXPORT void Jim_CollectIfNeeded (Jim_Interp *interp);
-
-
-JIM_EXPORT int Jim_GetIndex (Jim_Interp *interp, Jim_Obj *objPtr,
-        int *indexPtr);
-
-
-JIM_EXPORT Jim_Obj * Jim_NewListObj (Jim_Interp *interp,
-        Jim_Obj *const *elements, int len);
-JIM_EXPORT void Jim_ListInsertElements (Jim_Interp *interp,
-        Jim_Obj *listPtr, int listindex, int objc, Jim_Obj *const *objVec);
-JIM_EXPORT void Jim_ListAppendElement (Jim_Interp *interp,
-        Jim_Obj *listPtr, Jim_Obj *objPtr);
-JIM_EXPORT void Jim_ListAppendList (Jim_Interp *interp,
-        Jim_Obj *listPtr, Jim_Obj *appendListPtr);
-JIM_EXPORT int Jim_ListLength (Jim_Interp *interp, Jim_Obj *objPtr);
-JIM_EXPORT int Jim_ListIndex (Jim_Interp *interp, Jim_Obj *listPrt,
-        int listindex, Jim_Obj **objPtrPtr, int seterr);
-JIM_EXPORT Jim_Obj *Jim_ListGetIndex(Jim_Interp *interp, Jim_Obj *listPtr, int idx);
-JIM_EXPORT int Jim_SetListIndex (Jim_Interp *interp,
-        Jim_Obj *varNamePtr, Jim_Obj *const *indexv, int indexc,
-        Jim_Obj *newObjPtr);
-JIM_EXPORT Jim_Obj * Jim_ConcatObj (Jim_Interp *interp, int objc,
-        Jim_Obj *const *objv);
-JIM_EXPORT Jim_Obj *Jim_ListJoin(Jim_Interp *interp,
-        Jim_Obj *listObjPtr, const char *joinStr, int joinStrLen);
-
-
-JIM_EXPORT Jim_Obj * Jim_NewDictObj (Jim_Interp *interp,
-        Jim_Obj *const *elements, int len);
-JIM_EXPORT int Jim_DictKey (Jim_Interp *interp, Jim_Obj *dictPtr,
-        Jim_Obj *keyPtr, Jim_Obj **objPtrPtr, int flags);
-JIM_EXPORT int Jim_DictKeysVector (Jim_Interp *interp,
-        Jim_Obj *dictPtr, Jim_Obj *const *keyv, int keyc,
-        Jim_Obj **objPtrPtr, int flags);
-JIM_EXPORT int Jim_SetDictKeysVector (Jim_Interp *interp,
-        Jim_Obj *varNamePtr, Jim_Obj *const *keyv, int keyc,
-        Jim_Obj *newObjPtr, int flags);
-JIM_EXPORT Jim_Obj **Jim_DictPairs(Jim_Interp *interp,
-        Jim_Obj *dictPtr, int *len);
-JIM_EXPORT int Jim_DictAddElement(Jim_Interp *interp, Jim_Obj *objPtr,
-        Jim_Obj *keyObjPtr, Jim_Obj *valueObjPtr);
-
-#define JIM_DICTMATCH_KEYS 0x0001
-#define JIM_DICTMATCH_VALUES 0x002
-
-JIM_EXPORT int Jim_DictMatchTypes(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *patternObj, int match_type, int return_types);
-JIM_EXPORT int Jim_DictSize(Jim_Interp *interp, Jim_Obj *objPtr);
-JIM_EXPORT int Jim_DictInfo(Jim_Interp *interp, Jim_Obj *objPtr);
-JIM_EXPORT Jim_Obj *Jim_DictMerge(Jim_Interp *interp, int objc, Jim_Obj *const *objv);
-
-
-JIM_EXPORT int Jim_GetReturnCode (Jim_Interp *interp, Jim_Obj *objPtr,
-        int *intPtr);
-
-
-JIM_EXPORT int Jim_EvalExpression (Jim_Interp *interp,
-        Jim_Obj *exprObjPtr);
-JIM_EXPORT int Jim_GetBoolFromExpr (Jim_Interp *interp,
-        Jim_Obj *exprObjPtr, int *boolPtr);
-
-
-JIM_EXPORT int Jim_GetBoolean(Jim_Interp *interp, Jim_Obj *objPtr,
-        int *booleanPtr);
-
-
-JIM_EXPORT int Jim_GetWide (Jim_Interp *interp, Jim_Obj *objPtr,
-        jim_wide *widePtr);
-JIM_EXPORT int Jim_GetWideExpr(Jim_Interp *interp, Jim_Obj *objPtr,
-        jim_wide *widePtr);
-JIM_EXPORT int Jim_GetLong (Jim_Interp *interp, Jim_Obj *objPtr,
-        long *longPtr);
-#define Jim_NewWideObj  Jim_NewIntObj
-JIM_EXPORT Jim_Obj * Jim_NewIntObj (Jim_Interp *interp,
-        jim_wide wideValue);
-
-
-JIM_EXPORT int Jim_GetDouble(Jim_Interp *interp, Jim_Obj *objPtr,
-        double *doublePtr);
-JIM_EXPORT void Jim_SetDouble(Jim_Interp *interp, Jim_Obj *objPtr,
-        double doubleValue);
-JIM_EXPORT Jim_Obj * Jim_NewDoubleObj(Jim_Interp *interp, double doubleValue);
-
-
-JIM_EXPORT void Jim_WrongNumArgs (Jim_Interp *interp, int argc,
-        Jim_Obj *const *argv, const char *msg);
-JIM_EXPORT int Jim_GetEnum (Jim_Interp *interp, Jim_Obj *objPtr,
-        const char * const *tablePtr, int *indexPtr, const char *name, int flags);
-JIM_EXPORT int Jim_CheckShowCommands(Jim_Interp *interp, Jim_Obj *objPtr,
-        const char *const *tablePtr);
-JIM_EXPORT int Jim_ScriptIsComplete(Jim_Interp *interp,
-        Jim_Obj *scriptObj, char *stateCharPtr);
-
-JIM_EXPORT int Jim_FindByName(const char *name, const char * const array[], size_t len);
-
-
-typedef void (Jim_InterpDeleteProc)(Jim_Interp *interp, void *data);
-JIM_EXPORT void * Jim_GetAssocData(Jim_Interp *interp, const char *key);
-JIM_EXPORT int Jim_SetAssocData(Jim_Interp *interp, const char *key,
-        Jim_InterpDeleteProc *delProc, void *data);
-JIM_EXPORT int Jim_DeleteAssocData(Jim_Interp *interp, const char *key);
-JIM_EXPORT int Jim_CheckAbiVersion(Jim_Interp *interp, int abi_version);
-
-
-
-
-JIM_EXPORT int Jim_PackageProvide (Jim_Interp *interp,
-        const char *name, const char *ver, int flags);
-JIM_EXPORT int Jim_PackageRequire (Jim_Interp *interp,
-        const char *name, int flags);
-#define Jim_PackageProvideCheck(INTERP, NAME) \
-        if (Jim_CheckAbiVersion(INTERP, JIM_ABI_VERSION) == JIM_ERR || Jim_PackageProvide(INTERP, NAME, "1.0", JIM_ERRMSG)) \
-                return JIM_ERR
-
-
-JIM_EXPORT void Jim_MakeErrorMessage (Jim_Interp *interp);
-
-
-JIM_EXPORT int Jim_InteractivePrompt (Jim_Interp *interp);
-JIM_EXPORT void Jim_HistoryLoad(const char *filename);
-JIM_EXPORT void Jim_HistorySave(const char *filename);
-JIM_EXPORT char *Jim_HistoryGetline(Jim_Interp *interp, const char *prompt);
-JIM_EXPORT void Jim_HistorySetCompletion(Jim_Interp *interp, Jim_Obj *completionCommandObj);
-JIM_EXPORT void Jim_HistorySetHints(Jim_Interp *interp, Jim_Obj *hintsCommandObj);
-JIM_EXPORT void Jim_HistoryAdd(const char *line);
-JIM_EXPORT void Jim_HistoryShow(void);
-JIM_EXPORT void Jim_HistorySetMaxLen(int length);
-JIM_EXPORT int Jim_HistoryGetMaxLen(void);
-
-
-JIM_EXPORT int Jim_InitStaticExtensions(Jim_Interp *interp);
-JIM_EXPORT int Jim_StringToWide(const char *str, jim_wide *widePtr, int base);
-JIM_EXPORT int Jim_IsBigEndian(void);
-
-#define Jim_CheckSignal(i) ((i)->signal_level && (i)->sigmask)
-JIM_EXPORT void Jim_SignalSetIgnored(jim_wide mask);
-
-
-JIM_EXPORT int Jim_LoadLibrary(Jim_Interp *interp, const char *pathName);
-JIM_EXPORT void Jim_FreeLoadHandles(Jim_Interp *interp);
-
-
-JIM_EXPORT int Jim_AioFilehandle(Jim_Interp *interp, Jim_Obj *command);
-
-
-JIM_EXPORT int Jim_IsDict(Jim_Obj *objPtr);
-JIM_EXPORT int Jim_IsList(Jim_Obj *objPtr);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-#ifndef JIM_SUBCMD_H
-#define JIM_SUBCMD_H
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-#define JIM_MODFLAG_HIDDEN   0x0001
-#define JIM_MODFLAG_FULLARGV 0x0002
-
-
-
-typedef int jim_subcmd_function(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
-
-typedef struct {
-	const char *cmd;
-	const char *args;
-	jim_subcmd_function *function;
-	short minargs;
-	short maxargs;
-	unsigned short flags;
-} jim_subcmd_type;
-
-#define JIM_DEF_SUBCMD(name, args, minargs, maxargs) { name, args, NULL, minargs, maxargs }
-#define JIM_DEF_SUBCMD_HIDDEN(name, args, minargs, maxargs) { name, args, NULL, minargs, maxargs, JIM_MODFLAG_HIDDEN }
-
-const jim_subcmd_type *
-Jim_ParseSubCmd(Jim_Interp *interp, const jim_subcmd_type *command_table, int argc, Jim_Obj *const *argv);
-
-int Jim_SubCmdProc(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
-
-int Jim_CallSubCmd(Jim_Interp *interp, const jim_subcmd_type *ct, int argc, Jim_Obj *const *argv);
-
-void Jim_SubCmdArgError(Jim_Interp *interp, const jim_subcmd_type *ct, Jim_Obj *subcmd);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-#ifndef JIMREGEXP_H
-#define JIMREGEXP_H
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdlib.h>
-
-typedef struct {
-	int rm_so;
-	int rm_eo;
-} regmatch_t;
-
-
-typedef struct regexp {
-
-	int re_nsub;
-
-
-	int cflags;
-	int err;
-	int regstart;
-	int reganch;
-	int regmust;
-	int regmlen;
-	int *program;
-
-
-	const char *regparse;
-	int p;
-	int proglen;
-
-
-	int eflags;
-	const char *start;
-	const char *reginput;
-	const char *regbol;
-
-
-	regmatch_t *pmatch;
-	int nmatch;
-} regexp;
-
-typedef regexp regex_t;
-
-#define REG_EXTENDED 0
-#define REG_NEWLINE 1
-#define REG_ICASE 2
-
-#define REG_NOTBOL 16
-
-enum {
-	REG_NOERROR,
-	REG_NOMATCH,
-	REG_BADPAT,
-	REG_ERR_NULL_ARGUMENT,
-	REG_ERR_UNKNOWN,
-	REG_ERR_TOO_BIG,
-	REG_ERR_NOMEM,
-	REG_ERR_TOO_MANY_PAREN,
-	REG_ERR_UNMATCHED_PAREN,
-	REG_ERR_UNMATCHED_BRACES,
-	REG_ERR_BAD_COUNT,
-	REG_ERR_JUNK_ON_END,
-	REG_ERR_OPERAND_COULD_BE_EMPTY,
-	REG_ERR_NESTED_COUNT,
-	REG_ERR_INTERNAL,
-	REG_ERR_COUNT_FOLLOWS_NOTHING,
-	REG_ERR_INVALID_ESCAPE,
-	REG_ERR_CORRUPTED,
-	REG_ERR_NULL_CHAR,
-	REG_ERR_UNMATCHED_BRACKET,
-	REG_ERR_NUM
-};
-
-int jim_regcomp(regex_t *preg, const char *regex, int cflags);
-int jim_regexec(regex_t  *preg,  const  char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
-size_t jim_regerror(int errcode, const regex_t *preg, char *errbuf,  size_t errbuf_size);
-void jim_regfree(regex_t *preg);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-#ifndef JIM_SIGNAL_H
-#define JIM_SIGNAL_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-const char *Jim_SignalId(int sig);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-#ifndef JIMIOCOMPAT_H
-#define JIMIOCOMPAT_H
-
-
-#include <stdio.h>
-#include <errno.h>
-#include <sys/stat.h>
-
-
-void Jim_SetResultErrno(Jim_Interp *interp, const char *msg);
-
-int Jim_OpenForWrite(const char *filename, int append);
-
-int Jim_OpenForRead(const char *filename);
-
-#if defined(__MINGW32__) || defined(_WIN32)
-    #ifndef STRICT
-    #define STRICT
-    #endif
-    #define WIN32_LEAN_AND_MEAN
-    #include <windows.h>
-    #include <fcntl.h>
-    #include <io.h>
-    #include <process.h>
-
-    typedef HANDLE phandle_t;
-    #define JIM_BAD_PHANDLE INVALID_HANDLE_VALUE
-
-
-    #define WIFEXITED(STATUS) (((STATUS) & 0xff00) == 0)
-    #define WEXITSTATUS(STATUS) ((STATUS) & 0x00ff)
-    #define WIFSIGNALED(STATUS) (((STATUS) & 0xff00) != 0)
-    #define WTERMSIG(STATUS) (((STATUS) >> 8) & 0xff)
-    #define WNOHANG 1
-
-    int Jim_Errno(void);
-
-    long waitpid(phandle_t phandle, int *status, int nohang);
-
-    phandle_t JimWaitPid(long processid, int *status, int nohang);
-
-    long JimProcessPid(phandle_t phandle);
-
-    #define HAVE_PIPE
-    #define pipe(P) _pipe((P), 0, O_NOINHERIT)
-
-    typedef struct __stat64 jim_stat_t;
-    #define Jim_Stat _stat64
-    #define Jim_FileStat _fstat64
-    #define Jim_Lseek _lseeki64
-    #define O_TEXT _O_TEXT
-    #define O_BINARY _O_BINARY
-    #define Jim_SetMode _setmode
-    #ifndef STDIN_FILENO
-    #define STDIN_FILENO 0
-    #endif
-
-#else
-    #if defined(HAVE_STAT64)
-        typedef struct stat64 jim_stat_t;
-        #define Jim_Stat stat64
-        #if defined(HAVE_FSTAT64)
-            #define Jim_FileStat fstat64
-        #endif
-        #if defined(HAVE_LSTAT64)
-            #define Jim_LinkStat lstat64
-        #endif
-    #else
-        typedef struct stat jim_stat_t;
-        #define Jim_Stat stat
-        #if defined(HAVE_FSTAT)
-            #define Jim_FileStat fstat
-        #endif
-        #if defined(HAVE_LSTAT)
-            #define Jim_LinkStat lstat
-        #endif
-    #endif
-    #if defined(HAVE_LSEEK64)
-        #define Jim_Lseek lseek64
-    #else
-        #define Jim_Lseek lseek
-    #endif
-
-    #if defined(HAVE_UNISTD_H)
-        #include <unistd.h>
-        #include <fcntl.h>
-        #include <sys/wait.h>
-
-        typedef int phandle_t;
-        #define Jim_Errno() errno
-        #define JIM_BAD_PHANDLE -1
-        #define JimProcessPid(PIDTYPE) (PIDTYPE)
-        #define JimWaitPid waitpid
-
-        #ifndef HAVE_EXECVPE
-            #define execvpe(ARG0, ARGV, ENV) execvp(ARG0, ARGV)
-        #endif
-    #endif
-
-    #ifndef O_TEXT
-        #define O_TEXT 0
-    #endif
-
-#endif
-
-# ifndef MAXPATHLEN
-# ifdef PATH_MAX
-# define MAXPATHLEN PATH_MAX
-# else
-# define MAXPATHLEN JIM_PATH_LEN
-# endif
-# endif
-
-
-int Jim_FileStoreStatData(Jim_Interp *interp, Jim_Obj *varName, const jim_stat_t *sb);
-
-#endif
-int Jim_bootstrapInit(Jim_Interp *interp)
-{
-	if (Jim_PackageProvide(interp, "bootstrap", "1.0", JIM_ERRMSG))
-		return JIM_ERR;
-
-	return Jim_EvalSource(interp, "bootstrap.tcl", 1,
-"\n"
-"proc package {cmd args} {\n"
-"	if {$cmd eq \"require\"} {\n"
-"		foreach path $::auto_path {\n"
-"			lassign $args pkg\n"
-"			set pkgpath $path/$pkg.tcl\n"
-"			if {$path eq \".\"} {\n"
-"				set pkgpath $pkg.tcl\n"
-"			}\n"
-"			if {[file exists $pkgpath]} {\n"
-"				tailcall uplevel #0 [list source $pkgpath]\n"
-"			}\n"
-"		}\n"
-"	}\n"
-"}\n"
-"set tcl_platform(bootstrap) 1\n"
-);
-}
-int Jim_initjimshInit(Jim_Interp *interp)
-{
-	if (Jim_PackageProvide(interp, "initjimsh", "1.0", JIM_ERRMSG))
-		return JIM_ERR;
-
-	return Jim_EvalSource(interp, "initjimsh.tcl", 1,
-"\n"
-"\n"
-"\n"
-"proc _jimsh_init {} {\n"
-"	rename _jimsh_init {}\n"
-"	global jim::exe jim::argv0 tcl_interactive auto_path tcl_platform\n"
-"\n"
-"\n"
-"	if {[exists jim::argv0]} {\n"
-"		if {[string match \"*/*\" $jim::argv0]} {\n"
-"			set jim::exe [file join [pwd] $jim::argv0]\n"
-"		} else {\n"
-"			set jim::argv0 [file tail $jim::argv0]\n"
-"			set path [split [env PATH \"\"] $tcl_platform(pathSeparator)]\n"
-"			if {$tcl_platform(platform) eq \"windows\"} {\n"
-"\n"
-"				set path [lmap p [list \"\" {*}$path] { string map {\\\\ /} $p }]\n"
-"			}\n"
-"			foreach p $path {\n"
-"				set exec [file join [pwd] $p $jim::argv0]\n"
-"				if {[file executable $exec]} {\n"
-"					set jim::exe $exec\n"
-"					break\n"
-"				}\n"
-"			}\n"
-"		}\n"
-"	}\n"
-"\n"
-"\n"
-"	lappend p {*}[split [env JIMLIB {}] $tcl_platform(pathSeparator)]\n"
-"	if {[exists jim::exe]} {\n"
-"		lappend p [file dirname $jim::exe]\n"
-"	}\n"
-"	lappend p {*}$auto_path\n"
-"	set auto_path $p\n"
-"\n"
-"	if {$tcl_interactive && [env HOME {}] ne \"\"} {\n"
-"		foreach src {.jimrc jimrc.tcl} {\n"
-"			if {[file exists [env HOME]/$src]} {\n"
-"				uplevel #0 source [env HOME]/$src\n"
-"				break\n"
-"			}\n"
-"		}\n"
-"	}\n"
-"	return \"\"\n"
-"}\n"
-"\n"
-"if {$tcl_platform(platform) eq \"windows\"} {\n"
-"	set jim::argv0 [string map {\\\\ /} $jim::argv0]\n"
-"}\n"
-"\n"
-"\n"
-"set tcl::autocomplete_commands {array clock debug dict file history info namespace package signal socket string tcl::prefix zlib}\n"
-"\n"
-"\n"
-"\n"
-"proc tcl::autocomplete {prefix} {\n"
-"	if {[set space [string first \" \" $prefix]] != -1} {\n"
-"		set cmd [string range $prefix 0 $space-1]\n"
-"		if {$cmd in $::tcl::autocomplete_commands || [info channel $cmd] ne \"\"} {\n"
-"			set arg [string range $prefix $space+1 end]\n"
-"\n"
-"			return [lmap p [$cmd -commands] {\n"
-"				if {![string match \"${arg}*\" $p]} continue\n"
-"				function \"$cmd $p\"\n"
-"			}]\n"
-"		}\n"
-"	}\n"
-"\n"
-"	if {[string match \"source *\" $prefix]} {\n"
-"		set path [string range $prefix 7 end]\n"
-"		return [lmap p [glob -nocomplain \"${path}*\"] {\n"
-"			function \"source $p\"\n"
-"		}]\n"
-"	}\n"
-"\n"
-"	return [lmap p [lsort [info commands $prefix*]] {\n"
-"		if {[string match \"* *\" $p]} {\n"
-"			continue\n"
-"		}\n"
-"		function $p\n"
-"	}]\n"
-"}\n"
-"\n"
-"\n"
-"set tcl::stdhint_commands {array clock debug dict file history info namespace package signal string zlib}\n"
-"\n"
-"set tcl::stdhint_cols {\n"
-"	none {0}\n"
-"	black {30}\n"
-"	red {31}\n"
-"	green {32}\n"
-"	yellow {33}\n"
-"	blue {34}\n"
-"	purple {35}\n"
-"	cyan {36}\n"
-"	normal {37}\n"
-"	grey {30 1}\n"
-"	gray {30 1}\n"
-"	lred {31 1}\n"
-"	lgreen {32 1}\n"
-"	lyellow {33 1}\n"
-"	lblue {34 1}\n"
-"	lpurple {35 1}\n"
-"	lcyan {36 1}\n"
-"	white {37 1}\n"
-"}\n"
-"\n"
-"\n"
-"set tcl::stdhint_col $tcl::stdhint_cols(lcyan)\n"
-"\n"
-"\n"
-"proc tcl::stdhint {string} {\n"
-"	set result \"\"\n"
-"	if {[llength $string] >= 2} {\n"
-"		lassign $string cmd arg\n"
-"		if {$cmd in $::tcl::stdhint_commands || [info channel $cmd] ne \"\"} {\n"
-"			catch {\n"
-"				set help [$cmd -help $arg]\n"
-"				if {[string match \"Usage: $cmd *\" $help]} {\n"
-"					set n [llength $string]\n"
-"					set subcmd [lindex $help $n]\n"
-"					incr n\n"
-"					set hint [join [lrange $help $n end]]\n"
-"					set prefix \"\"\n"
-"					if {![string match \"* \" $string]} {\n"
-"						if {$n == 3 && $subcmd ne $arg} {\n"
-"\n"
-"							set prefix \"[string range $subcmd [string length $arg] end] \"\n"
-"						} else {\n"
-"							set prefix \" \"\n"
-"						}\n"
-"					}\n"
-"					set result [list $prefix$hint {*}$::tcl::stdhint_col]\n"
-"				}\n"
-"			}\n"
-"		}\n"
-"	}\n"
-"	return $result\n"
-"}\n"
-"\n"
-"_jimsh_init\n"
-);
-}
-int Jim_globInit(Jim_Interp *interp)
-{
-	if (Jim_PackageProvide(interp, "glob", "1.0", JIM_ERRMSG))
-		return JIM_ERR;
-
-	return Jim_EvalSource(interp, "glob.tcl", 1,
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"package require readdir\n"
-"\n"
-"\n"
-"proc glob.globdir {dir pattern} {\n"
-"	if {[file exists $dir/$pattern]} {\n"
-"\n"
-"		return [list $pattern]\n"
-"	}\n"
-"\n"
-"	set result {}\n"
-"	set files [readdir $dir]\n"
-"	lappend files . ..\n"
-"\n"
-"	foreach name $files {\n"
-"		if {[string match $pattern $name]} {\n"
-"\n"
-"			if {[string index $name 0] eq \".\" && [string index $pattern 0] ne \".\"} {\n"
-"				continue\n"
-"			}\n"
-"			lappend result $name\n"
-"		}\n"
-"	}\n"
-"\n"
-"	return $result\n"
-"}\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"proc glob.explode {pattern} {\n"
-"	set oldexp {}\n"
-"	set newexp {\"\"}\n"
-"\n"
-"	while 1 {\n"
-"		set oldexp $newexp\n"
-"		set newexp {}\n"
-"		set ob [string first \\{ $pattern]\n"
-"		set cb [string first \\} $pattern]\n"
-"\n"
-"		if {$ob < $cb && $ob != -1} {\n"
-"			set mid [string range $pattern 0 $ob-1]\n"
-"			set subexp [lassign [glob.explode [string range $pattern $ob+1 end]] pattern]\n"
-"			if {$pattern eq \"\"} {\n"
-"				error \"unmatched open brace in glob pattern\"\n"
-"			}\n"
-"			set pattern [string range $pattern 1 end]\n"
-"\n"
-"			foreach subs $subexp {\n"
-"				foreach sub [split $subs ,] {\n"
-"					foreach old $oldexp {\n"
-"						lappend newexp $old$mid$sub\n"
-"					}\n"
-"				}\n"
-"			}\n"
-"		} elseif {$cb != -1} {\n"
-"			set suf  [string range $pattern 0 $cb-1]\n"
-"			set rest [string range $pattern $cb end]\n"
-"			break\n"
-"		} else {\n"
-"			set suf  $pattern\n"
-"			set rest \"\"\n"
-"			break\n"
-"		}\n"
-"	}\n"
-"\n"
-"	foreach old $oldexp {\n"
-"		lappend newexp $old$suf\n"
-"	}\n"
-"	list $rest {*}$newexp\n"
-"}\n"
-"\n"
-"\n"
-"\n"
-"proc glob.glob {base pattern} {\n"
-"	set dir [file dirname $pattern]\n"
-"	if {$pattern eq $dir || $pattern eq \"\"} {\n"
-"		return [list [file join $base $dir] $pattern]\n"
-"	} elseif {$pattern eq [file tail $pattern]} {\n"
-"		set dir \"\"\n"
-"	}\n"
-"\n"
-"\n"
-"	set dirlist [glob.glob $base $dir]\n"
-"	set pattern [file tail $pattern]\n"
-"\n"
-"\n"
-"	set result {}\n"
-"	foreach {realdir dir} $dirlist {\n"
-"		if {![file isdir $realdir]} {\n"
-"			continue\n"
-"		}\n"
-"		if {[string index $dir end] ne \"/\" && $dir ne \"\"} {\n"
-"			append dir /\n"
-"		}\n"
-"		foreach name [glob.globdir $realdir $pattern] {\n"
-"			lappend result [file join $realdir $name] $dir$name\n"
-"		}\n"
-"	}\n"
-"	return $result\n"
-"}\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"proc glob {args} {\n"
-"	set nocomplain 0\n"
-"	set base \"\"\n"
-"	set tails 0\n"
-"\n"
-"	set n 0\n"
-"	foreach arg $args {\n"
-"		if {[info exists param]} {\n"
-"			set $param $arg\n"
-"			unset param\n"
-"			incr n\n"
-"			continue\n"
-"		}\n"
-"		switch -glob -- $arg {\n"
-"			-d* {\n"
-"				set switch $arg\n"
-"				set param base\n"
-"			}\n"
-"			-n* {\n"
-"				set nocomplain 1\n"
-"			}\n"
-"			-ta* {\n"
-"				set tails 1\n"
-"			}\n"
-"			-- {\n"
-"				incr n\n"
-"				break\n"
-"			}\n"
-"			-* {\n"
-"				return -code error \"bad option \\\"$arg\\\": must be -directory, -nocomplain, -tails, or --\"\n"
-"			}\n"
-"			*  {\n"
-"				break\n"
-"			}\n"
-"		}\n"
-"		incr n\n"
-"	}\n"
-"	if {[info exists param]} {\n"
-"		return -code error \"missing argument to \\\"$switch\\\"\"\n"
-"	}\n"
-"	if {[llength $args] <= $n} {\n"
-"		return -code error \"wrong # args: should be \\\"glob ?options? pattern ?pattern ...?\\\"\"\n"
-"	}\n"
-"\n"
-"	set args [lrange $args $n end]\n"
-"\n"
-"	set result {}\n"
-"	foreach pattern $args {\n"
-"		set escpattern [string map {\n"
-"			\\\\\\\\ \\x01 \\\\\\{ \\x02 \\\\\\} \\x03 \\\\, \\x04\n"
-"		} $pattern]\n"
-"		set patexps [lassign [glob.explode $escpattern] rest]\n"
-"		if {$rest ne \"\"} {\n"
-"			return -code error \"unmatched close brace in glob pattern\"\n"
-"		}\n"
-"		foreach patexp $patexps {\n"
-"			set patexp [string map {\n"
-"				\\x01 \\\\\\\\ \\x02 \\{ \\x03 \\} \\x04 ,\n"
-"			} $patexp]\n"
-"			foreach {realname name} [glob.glob $base $patexp] {\n"
-"				incr n\n"
-"				if {$tails} {\n"
-"					lappend result $name\n"
-"				} else {\n"
-"					lappend result [file join $base $name]\n"
-"				}\n"
-"			}\n"
-"		}\n"
-"	}\n"
-"\n"
-"	if {!$nocomplain && [llength $result] == 0} {\n"
-"		set s $(([llength $args] > 1) ? \"s\" : \"\")\n"
-"		return -code error \"no files matched glob pattern$s \\\"[join $args]\\\"\"\n"
-"	}\n"
-"\n"
-"	return $result\n"
-"}\n"
-);
-}
-int Jim_stdlibInit(Jim_Interp *interp)
-{
-	if (Jim_PackageProvide(interp, "stdlib", "1.0", JIM_ERRMSG))
-		return JIM_ERR;
-
-	return Jim_EvalSource(interp, "stdlib.tcl", 1,
-"\n"
-"\n"
-"if {![exists -command ref]} {\n"
-"\n"
-"	proc ref {args} {{count 0}} {\n"
-"		format %08x [incr count]\n"
-"	}\n"
-"}\n"
-"\n"
-"\n"
-"proc lambda {arglist args} {\n"
-"	tailcall proc [ref {} function lambda.finalizer] $arglist {*}$args\n"
-"}\n"
-"\n"
-"proc lambda.finalizer {name val} {\n"
-"	rename $name {}\n"
-"}\n"
-"\n"
-"\n"
-"proc curry {args} {\n"
-"	alias [ref {} function lambda.finalizer] {*}$args\n"
-"}\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"proc function {value} {\n"
-"	return $value\n"
-"}\n"
-"\n"
-"\n"
-"proc stackdump {stacktrace} {\n"
-"	set lines {}\n"
-"	lappend lines \"Traceback (most recent call last):\"\n"
-"	foreach {cmd l f p} [lreverse $stacktrace] {\n"
-"		set line {}\n"
-"		if {$f ne \"\"} {\n"
-"			append line \"  File \\\"$f\\\", line $l\"\n"
-"		}\n"
-"		if {$p ne \"\"} {\n"
-"			append line \", in $p\"\n"
-"		}\n"
-"		if {$line ne \"\"} {\n"
-"			lappend lines $line\n"
-"			if {$cmd ne \"\"} {\n"
-"				set nl [string first \\n $cmd 1]\n"
-"				if {$nl >= 0} {\n"
-"					set cmd [string range $cmd 0 $nl-1]...\n"
-"				}\n"
-"				lappend lines \"    $cmd\"\n"
-"			}\n"
-"		}\n"
-"	}\n"
-"	if {[llength $lines] > 1} {\n"
-"		return [join $lines \\n]\n"
-"	}\n"
-"}\n"
-"\n"
-"\n"
-"\n"
-"proc defer {script} {\n"
-"	upvar jim::defer v\n"
-"	lappend v $script\n"
-"}\n"
-"\n"
-"\n"
-"\n"
-"proc errorInfo {msg {stacktrace \"\"}} {\n"
-"	if {$stacktrace eq \"\"} {\n"
-"\n"
-"		set stacktrace [info stacktrace]\n"
-"	}\n"
-"	lassign $stacktrace p f l cmd\n"
-"	if {$f ne \"\"} {\n"
-"		set result \"$f:$l: Error: \"\n"
-"	}\n"
-"	append result \"$msg\\n\"\n"
-"	append result [stackdump $stacktrace]\n"
-"\n"
-"\n"
-"	string trim $result\n"
-"}\n"
-"\n"
-"\n"
-"\n"
-"proc {info nameofexecutable} {} {\n"
-"	if {[exists ::jim::exe]} {\n"
-"		return $::jim::exe\n"
-"	}\n"
-"}\n"
-"\n"
-"\n"
-"proc {dict update} {&varName args script} {\n"
-"	set keys {}\n"
-"	foreach {n v} $args {\n"
-"		upvar $v var_$v\n"
-"		if {[dict exists $varName $n]} {\n"
-"			set var_$v [dict get $varName $n]\n"
-"		}\n"
-"	}\n"
-"	catch {uplevel 1 $script} msg opts\n"
-"	if {[info exists varName]} {\n"
-"		foreach {n v} $args {\n"
-"			if {[info exists var_$v]} {\n"
-"				dict set varName $n [set var_$v]\n"
-"			} else {\n"
-"				dict unset varName $n\n"
-"			}\n"
-"		}\n"
-"	}\n"
-"	return {*}$opts $msg\n"
-"}\n"
-"\n"
-"proc {dict replace} {dictionary {args {key value}}} {\n"
-"	if {[llength ${key value}] % 2} {\n"
-"		tailcall {dict replace}\n"
-"	}\n"
-"	tailcall dict merge $dictionary ${key value}\n"
-"}\n"
-"\n"
-"\n"
-"proc {dict lappend} {varName key {args value}} {\n"
-"	upvar $varName dict\n"
-"	if {[exists dict] && [dict exists $dict $key]} {\n"
-"		set list [dict get $dict $key]\n"
-"	}\n"
-"	lappend list {*}$value\n"
-"	dict set dict $key $list\n"
-"}\n"
-"\n"
-"\n"
-"proc {dict append} {varName key {args value}} {\n"
-"	upvar $varName dict\n"
-"	if {[exists dict] && [dict exists $dict $key]} {\n"
-"		set str [dict get $dict $key]\n"
-"	}\n"
-"	append str {*}$value\n"
-"	dict set dict $key $str\n"
-"}\n"
-"\n"
-"\n"
-"proc {dict incr} {varName key {increment 1}} {\n"
-"	upvar $varName dict\n"
-"	if {[exists dict] && [dict exists $dict $key]} {\n"
-"		set value [dict get $dict $key]\n"
-"	}\n"
-"	incr value $increment\n"
-"	dict set dict $key $value\n"
-"}\n"
-"\n"
-"\n"
-"proc {dict remove} {dictionary {args key}} {\n"
-"	foreach k $key {\n"
-"		dict unset dictionary $k\n"
-"	}\n"
-"	return $dictionary\n"
-"}\n"
-"\n"
-"\n"
-"proc {dict for} {vars dictionary script} {\n"
-"	if {[llength $vars] != 2} {\n"
-"		return -code error \"must have exactly two variable names\"\n"
-"	}\n"
-"	dict size $dictionary\n"
-"	tailcall foreach $vars $dictionary $script\n"
-"}\n"
-);
-}
-int Jim_tclcompatInit(Jim_Interp *interp)
-{
-	if (Jim_PackageProvide(interp, "tclcompat", "1.0", JIM_ERRMSG))
-		return JIM_ERR;
-
-	return Jim_EvalSource(interp, "tclcompat.tcl", 1,
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"set env [env]\n"
-"\n"
-"\n"
-"if {[exists -command stdout]} {\n"
-"\n"
-"	foreach p {gets flush close eof seek tell} {\n"
-"		proc $p {chan args} {p} {\n"
-"			tailcall $chan $p {*}$args\n"
-"		}\n"
-"	}\n"
-"	unset p\n"
-"\n"
-"\n"
-"\n"
-"	proc puts {{-nonewline {}} {chan stdout} msg} {\n"
-"		if {${-nonewline} ni {-nonewline {}}} {\n"
-"			tailcall ${-nonewline} puts $msg\n"
-"		}\n"
-"		tailcall $chan puts {*}${-nonewline} $msg\n"
-"	}\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"	proc read {{-nonewline {}} chan} {\n"
-"		if {${-nonewline} ni {-nonewline {}}} {\n"
-"			tailcall ${-nonewline} read {*}${chan}\n"
-"		}\n"
-"		tailcall $chan read {*}${-nonewline}\n"
-"	}\n"
-"\n"
-"	proc fconfigure {f args} {\n"
-"		foreach {n v} $args {\n"
-"			switch -glob -- $n {\n"
-"				-bl* {\n"
-"					$f ndelay $(!$v)\n"
-"				}\n"
-"				-bu* {\n"
-"					$f buffering $v\n"
-"				}\n"
-"				-tr* {\n"
-"					$f translation $v\n"
-"				}\n"
-"				default {\n"
-"					return -code error \"fconfigure: unknown option $n\"\n"
-"				}\n"
-"			}\n"
-"		}\n"
-"	}\n"
-"}\n"
-"\n"
-"\n"
-"proc fileevent {args} {\n"
-"	tailcall {*}$args\n"
-"}\n"
-"\n"
-"\n"
-"\n"
-"proc parray {arrayname {pattern *} {puts puts}} {\n"
-"	upvar $arrayname a\n"
-"\n"
-"	set max 0\n"
-"	foreach name [array names a $pattern]] {\n"
-"		if {[string length $name] > $max} {\n"
-"			set max [string length $name]\n"
-"		}\n"
-"	}\n"
-"	incr max [string length $arrayname]\n"
-"	incr max 2\n"
-"	foreach name [lsort [array names a $pattern]] {\n"
-"		$puts [format \"%-${max}s = %s\" $arrayname\\($name\\) $a($name)]\n"
-"	}\n"
-"}\n"
-"\n"
-"\n"
-"proc {file copy} {{force {}} source target} {\n"
-"	try {\n"
-"		if {$force ni {{} -force}} {\n"
-"			error \"bad option \\\"$force\\\": should be -force\"\n"
-"		}\n"
-"\n"
-"		set in [open $source rb]\n"
-"\n"
-"		if {[file exists $target]} {\n"
-"			if {$force eq \"\"} {\n"
-"				error \"error copying \\\"$source\\\" to \\\"$target\\\": file already exists\"\n"
-"			}\n"
-"\n"
-"			if {$source eq $target} {\n"
-"				return\n"
-"			}\n"
-"\n"
-"\n"
-"			file stat $source ss\n"
-"			file stat $target ts\n"
-"			if {$ss(dev) == $ts(dev) && $ss(ino) == $ts(ino) && $ss(ino)} {\n"
-"				return\n"
-"			}\n"
-"		}\n"
-"		set out [open $target wb]\n"
-"		$in copyto $out\n"
-"		$out close\n"
-"	} on error {msg opts} {\n"
-"		incr opts(-level)\n"
-"		return {*}$opts $msg\n"
-"	} finally {\n"
-"		catch {$in close}\n"
-"	}\n"
-"}\n"
-"\n"
-"\n"
-"\n"
-"proc popen {cmd {mode r}} {\n"
-"	lassign [pipe] r w\n"
-"	try {\n"
-"		if {[string match \"w*\" $mode]} {\n"
-"			lappend cmd <@$r &\n"
-"			set pids [exec {*}$cmd]\n"
-"			$r close\n"
-"			set f $w\n"
-"		} else {\n"
-"			lappend cmd >@$w &\n"
-"			set pids [exec {*}$cmd]\n"
-"			$w close\n"
-"			set f $r\n"
-"		}\n"
-"		lambda {cmd args} {f pids} {\n"
-"			if {$cmd eq \"pid\"} {\n"
-"				return $pids\n"
-"			}\n"
-"			if {$cmd eq \"close\"} {\n"
-"				$f close\n"
-"\n"
-"				set retopts {}\n"
-"				foreach p $pids {\n"
-"					lassign [wait $p] status - rc\n"
-"					if {$status eq \"CHILDSTATUS\"} {\n"
-"						if {$rc == 0} {\n"
-"							continue\n"
-"						}\n"
-"						set msg \"child process exited abnormally\"\n"
-"					} else {\n"
-"						set msg \"child killed: received signal\"\n"
-"					}\n"
-"					set retopts [list -code error -errorcode [list $status $p $rc] $msg]\n"
-"				}\n"
-"				return {*}$retopts\n"
-"			}\n"
-"			tailcall $f $cmd {*}$args\n"
-"		}\n"
-"	} on error {error opts} {\n"
-"		$r close\n"
-"		$w close\n"
-"		error $error\n"
-"	}\n"
-"}\n"
-"\n"
-"\n"
-"local proc pid {{channelId {}}} {\n"
-"	if {$channelId eq \"\"} {\n"
-"		tailcall upcall pid\n"
-"	}\n"
-"	if {[catch {$channelId tell}]} {\n"
-"		return -code error \"can not find channel named \\\"$channelId\\\"\"\n"
-"	}\n"
-"	if {[catch {$channelId pid} pids]} {\n"
-"		return \"\"\n"
-"	}\n"
-"	return $pids\n"
-"}\n"
-"\n"
-"\n"
-"\n"
-"proc throw {code {msg \"\"}} {\n"
-"	return -code $code $msg\n"
-"}\n"
-"\n"
-"\n"
-"proc {file delete force} {path} {\n"
-"	foreach e [readdir $path] {\n"
-"		file delete -force $path/$e\n"
-"	}\n"
-"	file delete $path\n"
-"}\n"
-);
-}
-
-
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <assert.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#include <sys/stat.h>
-#endif
-#ifdef HAVE_UTIL_H
-#include <util.h>
-#endif
-#ifdef HAVE_PTY_H
-#include <pty.h>
-#endif
-
-
-#if defined(HAVE_SYS_SOCKET_H) && defined(HAVE_SELECT) && defined(HAVE_NETINET_IN_H) && defined(HAVE_NETDB_H) && defined(HAVE_ARPA_INET_H)
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#ifdef HAVE_SYS_UN_H
-#include <sys/un.h>
-#endif
-#define HAVE_SOCKETS
-#elif defined (__MINGW32__)
-
-#endif
-
-#if defined(JIM_SSL)
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-#endif
-
-#ifdef HAVE_TERMIOS_H
-#endif
-
-
-#define AIO_CMD_LEN 32
-#define AIO_DEFAULT_RBUF_LEN 256
-#define AIO_DEFAULT_WBUF_LIMIT (64 * 1024)
-
-#define AIO_KEEPOPEN 1
-#define AIO_NODELETE 2
-#define AIO_EOF 4
-#define AIO_WBUF_NONE 8
-#define AIO_NONBLOCK 16
-
-#define AIO_ONEREAD 32
-
-enum wbuftype {
-    WBUF_OPT_NONE,
-    WBUF_OPT_LINE,
-    WBUF_OPT_FULL,
-};
-
-#if defined(JIM_IPV6)
-#define IPV6 1
-#else
-#define IPV6 0
-#ifndef PF_INET6
-#define PF_INET6 0
-#endif
-#endif
-#if defined(HAVE_SYS_UN_H) && defined(PF_UNIX)
-#define UNIX_SOCKETS 1
-#else
-#define UNIX_SOCKETS 0
-#endif
-
-
-
-
-static int JimReadableTimeout(int fd, long ms)
-{
-#ifdef HAVE_SELECT
-    int retval;
-    struct timeval tv;
-    fd_set rfds;
-
-    FD_ZERO(&rfds);
-
-    FD_SET(fd, &rfds);
-    tv.tv_sec = ms / 1000;
-    tv.tv_usec = (ms % 1000) * 1000;
-
-    retval = select(fd + 1, &rfds, NULL, NULL, ms == 0 ? NULL : &tv);
-
-    if (retval > 0) {
-        return JIM_OK;
-    }
-    return JIM_ERR;
-#else
-    return JIM_OK;
-#endif
-}
-
-
-struct AioFile;
-
-typedef struct {
-    int (*writer)(struct AioFile *af, const char *buf, int len);
-    int (*reader)(struct AioFile *af, char *buf, int len, int pending);
-    int (*error)(const struct AioFile *af);
-    const char *(*strerror)(struct AioFile *af);
-    int (*verify)(struct AioFile *af);
-} JimAioFopsType;
-
-typedef struct AioFile
-{
-    Jim_Obj *filename;
-    int wbuft;
-    int flags;
-    long timeout;
-    int fd;
-    int addr_family;
-    void *ssl;
-    const JimAioFopsType *fops;
-    Jim_Obj *readbuf;
-    Jim_Obj *writebuf;
-    char *rbuf;
-    size_t rbuf_len;
-    size_t wbuf_limit;
-} AioFile;
-
-static void aio_consume(Jim_Obj *objPtr, int n);
-
-static int stdio_writer(struct AioFile *af, const char *buf, int len)
-{
-    int ret = write(af->fd, buf, len);
-    if (ret < 0 && errno == EPIPE) {
-        aio_consume(af->writebuf, Jim_Length(af->writebuf));
-    }
-    return ret;
-}
-
-static int stdio_reader(struct AioFile *af, char *buf, int len, int nb)
-{
-    if (nb || af->timeout == 0 || JimReadableTimeout(af->fd, af->timeout) == JIM_OK) {
-
-        int ret;
-
-        errno = 0;
-        ret = read(af->fd, buf, len);
-        if (ret <= 0 && errno != EAGAIN && errno != EINTR) {
-            af->flags |= AIO_EOF;
-        }
-        return ret;
-    }
-    errno = ETIMEDOUT;
-    return -1;
-}
-
-static int stdio_error(const AioFile *af)
-{
-    if (af->flags & AIO_EOF) {
-        return JIM_OK;
-    }
-
-    switch (errno) {
-        case EAGAIN:
-        case EINTR:
-        case ETIMEDOUT:
-#ifdef ECONNRESET
-        case ECONNRESET:
-#endif
-#ifdef ECONNABORTED
-        case ECONNABORTED:
-#endif
-            return JIM_OK;
-        default:
-            return JIM_ERR;
-    }
-}
-
-static const char *stdio_strerror(struct AioFile *af)
-{
-    return strerror(errno);
-}
-
-static const JimAioFopsType stdio_fops = {
-    stdio_writer,
-    stdio_reader,
-    stdio_error,
-    stdio_strerror,
-    NULL,
-};
-
-
-static void aio_set_nonblocking(AioFile *af, int nb)
-{
-#ifdef O_NDELAY
-    int old = !!(af->flags & AIO_NONBLOCK);
-    if (old != nb) {
-        int fmode = fcntl(af->fd, F_GETFL);
-        if (nb) {
-            fmode |= O_NDELAY;
-            af->flags |= AIO_NONBLOCK;
-        }
-        else {
-            fmode &= ~O_NDELAY;
-            af->flags &= ~AIO_NONBLOCK;
-        }
-        (void)fcntl(af->fd, F_SETFL, fmode);
-    }
-#endif
-}
-
-static int aio_start_nonblocking(AioFile *af)
-{
-    int old = !!(af->flags & AIO_NONBLOCK);
-    if (af->timeout) {
-        aio_set_nonblocking(af, 1);
-    }
-    return old;
-}
-
-static int JimAioSubCmdProc(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
-static AioFile *JimMakeChannel(Jim_Interp *interp, int fd, Jim_Obj *filename,
-    const char *hdlfmt, int family, int flags);
-
-
-static const char *JimAioErrorString(AioFile *af)
-{
-    if (af && af->fops)
-        return af->fops->strerror(af);
-
-    return strerror(errno);
-}
-
-static void JimAioSetError(Jim_Interp *interp, Jim_Obj *name)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-
-    if (name) {
-        Jim_SetResultFormatted(interp, "%#s: %s", name, JimAioErrorString(af));
-    }
-    else {
-        Jim_SetResultString(interp, JimAioErrorString(af), -1);
-    }
-}
-
-static int aio_eof(AioFile *af)
-{
-    return af->flags & AIO_EOF;
-}
-
-static int JimCheckStreamError(Jim_Interp *interp, AioFile *af)
-{
-    int ret = 0;
-    if (!aio_eof(af)) {
-        ret = af->fops->error(af);
-        if (ret) {
-            JimAioSetError(interp, af->filename);
-        }
-    }
-    return ret;
-}
-
-static void aio_consume(Jim_Obj *objPtr, int n)
-{
-    assert(objPtr->bytes);
-    assert(n <= objPtr->length);
-
-
-    memmove(objPtr->bytes, objPtr->bytes + n, objPtr->length - n + 1);
-    objPtr->length -= n;
-}
-
-
-static int aio_flush(Jim_Interp *interp, AioFile *af);
-
-#ifdef jim_ext_eventloop
-static int aio_autoflush(Jim_Interp *interp, void *clientData, int mask)
-{
-    AioFile *af = clientData;
-
-    aio_flush(interp, af);
-    if (Jim_Length(af->writebuf) == 0) {
-
-        return -1;
-    }
-    return 0;
-}
-#endif
-
-
-static int aio_flush(Jim_Interp *interp, AioFile *af)
-{
-    int len;
-    const char *pt = Jim_GetString(af->writebuf, &len);
-    if (len) {
-        int ret = af->fops->writer(af, pt, len);
-        if (ret > 0) {
-
-            aio_consume(af->writebuf, ret);
-        }
-        if (ret < 0) {
-            return JimCheckStreamError(interp, af);
-        }
-        if (Jim_Length(af->writebuf)) {
-#ifdef jim_ext_eventloop
-            void *handler = Jim_FindFileHandler(interp, af->fd, JIM_EVENT_WRITABLE);
-            if (handler == NULL) {
-                Jim_CreateFileHandler(interp, af->fd, JIM_EVENT_WRITABLE, aio_autoflush, af, NULL);
-                return JIM_OK;
-            }
-            else if (handler == af) {
-
-                return JIM_OK;
-            }
-#endif
-
-            Jim_SetResultString(interp, "send buffer is full", -1);
-            return JIM_ERR;
-        }
-    }
-    return JIM_OK;
-}
-
-static int aio_read_len(Jim_Interp *interp, AioFile *af, unsigned flags, int neededLen)
-{
-    if (!af->readbuf) {
-        af->readbuf = Jim_NewStringObj(interp, NULL, 0);
-    }
-
-    if (neededLen >= 0) {
-        neededLen -= Jim_Length(af->readbuf);
-        if (neededLen <= 0) {
-            return JIM_OK;
-        }
-    }
-
-    while (neededLen && !aio_eof(af)) {
-        int retval;
-        int readlen;
-
-        if (neededLen == -1) {
-            readlen = af->rbuf_len;
-        }
-        else {
-            readlen = (neededLen > af->rbuf_len ? af->rbuf_len : neededLen);
-        }
-
-        if (!af->rbuf) {
-            af->rbuf = Jim_Alloc(af->rbuf_len);
-        }
-        retval = af->fops->reader(af, af->rbuf, readlen, flags & AIO_NONBLOCK);
-        if (retval > 0) {
-            if (retval) {
-                Jim_AppendString(interp, af->readbuf, af->rbuf, retval);
-            }
-            if (neededLen != -1) {
-                neededLen -= retval;
-            }
-            if (flags & AIO_ONEREAD) {
-                return JIM_OK;
-            }
-            continue;
-        }
-        if ((flags & AIO_ONEREAD) || JimCheckStreamError(interp, af)) {
-            return JIM_ERR;
-        }
-        break;
-    }
-
-    return JIM_OK;
-}
-
-static Jim_Obj *aio_read_consume(Jim_Interp *interp, AioFile *af, int neededLen)
-{
-    Jim_Obj *objPtr = NULL;
-
-    if (neededLen < 0 || af->readbuf == NULL || Jim_Length(af->readbuf) <= neededLen) {
-        objPtr = af->readbuf;
-        af->readbuf = NULL;
-    }
-    else if (af->readbuf) {
-
-        int len;
-        const char *pt = Jim_GetString(af->readbuf, &len);
-
-        objPtr  = Jim_NewStringObj(interp, pt, neededLen);
-        aio_consume(af->readbuf, neededLen);
-    }
-
-    return objPtr;
-}
-
-static void JimAioDelProc(Jim_Interp *interp, void *privData)
-{
-    AioFile *af = privData;
-
-    JIM_NOTUSED(interp);
-
-
-    aio_flush(interp, af);
-    Jim_DecrRefCount(interp, af->writebuf);
-
-#if UNIX_SOCKETS
-    if (af->addr_family == PF_UNIX && (af->flags & AIO_NODELETE) == 0) {
-
-        Jim_Obj *filenameObj = aio_sockname(interp, af->fd);
-        if (filenameObj) {
-            if (Jim_Length(filenameObj)) {
-                remove(Jim_String(filenameObj));
-            }
-            Jim_FreeNewObj(interp, filenameObj);
-        }
-    }
-#endif
-
-    Jim_DecrRefCount(interp, af->filename);
-
-#ifdef jim_ext_eventloop
-
-    Jim_DeleteFileHandler(interp, af->fd, JIM_EVENT_READABLE | JIM_EVENT_WRITABLE | JIM_EVENT_EXCEPTION);
-#endif
-
-#if defined(JIM_SSL)
-    if (af->ssl != NULL) {
-        SSL_free(af->ssl);
-    }
-#endif
-    if (!(af->flags & AIO_KEEPOPEN)) {
-        close(af->fd);
-    }
-    if (af->readbuf) {
-        Jim_FreeNewObj(interp, af->readbuf);
-    }
-
-    Jim_Free(af->rbuf);
-    Jim_Free(af);
-}
-
-static int aio_cmd_read(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-    int nonewline = 0;
-    jim_wide neededLen = -1;
-    static const char * const options[] = { "-pending", "-nonewline", NULL };
-    enum { OPT_PENDING, OPT_NONEWLINE };
-    int option;
-    int nb;
-    Jim_Obj *objPtr;
-
-    if (argc) {
-        if (*Jim_String(argv[0]) == '-') {
-            if (Jim_GetEnum(interp, argv[0], options, &option, NULL, JIM_ERRMSG) != JIM_OK) {
-                return JIM_ERR;
-            }
-            switch (option) {
-                case OPT_PENDING:
-
-                    break;
-                case OPT_NONEWLINE:
-                    nonewline++;
-                    break;
-            }
-        }
-        else {
-            if (Jim_GetWide(interp, argv[0], &neededLen) != JIM_OK)
-                return JIM_ERR;
-            if (neededLen < 0) {
-                Jim_SetResultString(interp, "invalid parameter: negative len", -1);
-                return JIM_ERR;
-            }
-        }
-        argc--;
-        argv++;
-    }
-    if (argc) {
-        return -1;
-    }
-
-
-    nb = aio_start_nonblocking(af);
-
-    if (aio_read_len(interp, af, nb ? AIO_NONBLOCK : 0, neededLen) != JIM_OK) {
-        aio_set_nonblocking(af, nb);
-        return JIM_ERR;
-    }
-    objPtr = aio_read_consume(interp, af, neededLen);
-
-    aio_set_nonblocking(af, nb);
-
-    if (objPtr) {
-        if (nonewline) {
-            int len;
-            const char *s = Jim_GetString(objPtr, &len);
-
-            if (len > 0 && s[len - 1] == '\n') {
-                objPtr->length--;
-                objPtr->bytes[objPtr->length] = '\0';
-            }
-        }
-        Jim_SetResult(interp, objPtr);
-    }
-    else {
-        Jim_SetEmptyResult(interp);
-    }
-    return JIM_OK;
-}
-
-int Jim_AioFilehandle(Jim_Interp *interp, Jim_Obj *command)
-{
-    Jim_Cmd *cmdPtr = Jim_GetCommand(interp, command, JIM_ERRMSG);
-
-
-    if (cmdPtr && !cmdPtr->isproc && cmdPtr->u.native.cmdProc == JimAioSubCmdProc) {
-        return ((AioFile *) cmdPtr->u.native.privData)->fd;
-    }
-    Jim_SetResultFormatted(interp, "Not a filehandle: \"%#s\"", command);
-    return -1;
-}
-
-static int aio_cmd_getfd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-
-
-    aio_flush(interp, af);
-
-    Jim_SetResultInt(interp, af->fd);
-
-    return JIM_OK;
-}
-
-static int aio_cmd_copy(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-    jim_wide count = 0;
-    jim_wide maxlen = JIM_WIDE_MAX;
-    int ok = 1;
-    Jim_Obj *objv[4];
-
-    if (argc == 2) {
-        if (Jim_GetWide(interp, argv[1], &maxlen) != JIM_OK) {
-            return JIM_ERR;
-        }
-    }
-
-    objv[0] = argv[0];
-    objv[1] = Jim_NewStringObj(interp, "flush", -1);
-    if (Jim_EvalObjVector(interp, 2, objv) != JIM_OK) {
-        Jim_SetResultFormatted(interp, "Not a filehandle: \"%#s\"", argv[0]);
-        return JIM_ERR;
-    }
-
-
-    objv[0] = argv[0];
-    objv[1] = Jim_NewStringObj(interp, "puts", -1);
-    objv[2] = Jim_NewStringObj(interp, "-nonewline", -1);
-    Jim_IncrRefCount(objv[1]);
-    Jim_IncrRefCount(objv[2]);
-
-    while (count < maxlen) {
-        jim_wide len = maxlen - count;
-        if (len > af->rbuf_len) {
-            len = af->rbuf_len;
-        }
-        if (aio_read_len(interp, af, 0, len) != JIM_OK) {
-            ok = 0;
-            break;
-        }
-        objv[3] = aio_read_consume(interp, af, len);
-        count += Jim_Length(objv[3]);
-        if (Jim_EvalObjVector(interp, 4, objv) != JIM_OK) {
-            ok = 0;
-            break;
-        }
-        if (aio_eof(af)) {
-            break;
-        }
-        if (count >= 16384 && af->rbuf_len < 65536) {
-
-            af->rbuf_len = 65536;
-            af->rbuf = Jim_Realloc(af->rbuf, af->rbuf_len);
-        }
-    }
-
-    Jim_DecrRefCount(interp, objv[1]);
-    Jim_DecrRefCount(interp, objv[2]);
-
-    if (!ok) {
-        return JIM_ERR;
-    }
-
-    Jim_SetResultInt(interp, count);
-
-    return JIM_OK;
-}
-
-static int aio_cmd_gets(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-    Jim_Obj *objPtr = NULL;
-    int len;
-    int nb;
-    unsigned flags = AIO_ONEREAD;
-    char *nl = NULL;
-    int offset = 0;
-
-    errno = 0;
-
-
-    nb = aio_start_nonblocking(af);
-    if (nb) {
-        flags |= AIO_NONBLOCK;
-    }
-
-    while (!aio_eof(af)) {
-        if (af->readbuf) {
-            const char *pt = Jim_GetString(af->readbuf, &len);
-            nl = memchr(pt + offset, '\n', len - offset);
-            if (nl) {
-
-                objPtr = Jim_NewStringObj(interp, pt, nl - pt);
-
-                aio_consume(af->readbuf, nl - pt + 1);
-                break;
-            }
-            offset = len;
-        }
-
-
-        if (aio_read_len(interp, af, flags, -1) != JIM_OK) {
-            break;
-        }
-    }
-
-    aio_set_nonblocking(af, nb);
-
-    if (!nl && aio_eof(af) && af->readbuf) {
-
-        objPtr = af->readbuf;
-        af->readbuf = NULL;
-    }
-    else if (!objPtr) {
-        objPtr = Jim_NewStringObj(interp, NULL, 0);
-    }
-
-    if (argc) {
-        if (Jim_SetVariable(interp, argv[0], objPtr) != JIM_OK) {
-            Jim_FreeNewObj(interp, objPtr);
-            return JIM_ERR;
-        }
-
-        len = Jim_Length(objPtr);
-
-        if (!nl && len == 0) {
-
-            len = -1;
-        }
-        Jim_SetResultInt(interp, len);
-    }
-    else {
-        Jim_SetResult(interp, objPtr);
-    }
-    return JIM_OK;
-}
-
-static int aio_cmd_puts(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-    int wlen;
-    const char *wdata;
-    Jim_Obj *strObj;
-    int wnow = 0;
-    int nl = 1;
-
-    if (argc == 2) {
-        if (!Jim_CompareStringImmediate(interp, argv[0], "-nonewline")) {
-            return -1;
-        }
-        strObj = argv[1];
-        nl = 0;
-    }
-    else {
-        strObj = argv[0];
-    }
-
-#ifdef JIM_MAINTAINER
-    if (Jim_IsShared(af->writebuf)) {
-        Jim_DecrRefCount(interp, af->writebuf);
-        af->writebuf = Jim_DuplicateObj(interp, af->writebuf);
-        Jim_IncrRefCount(af->writebuf);
-    }
-#endif
-    Jim_AppendObj(interp, af->writebuf, strObj);
-    if (nl) {
-        Jim_AppendString(interp, af->writebuf, "\n", 1);
-    }
-
-
-    wdata = Jim_GetString(af->writebuf, &wlen);
-    switch (af->wbuft) {
-        case WBUF_OPT_NONE:
-
-            wnow = 1;
-            break;
-
-        case WBUF_OPT_LINE:
-
-            if (nl || memchr(wdata, '\n', wlen) != NULL) {
-                wnow = 1;
-            }
-            break;
-
-        case WBUF_OPT_FULL:
-            if (wlen >= af->wbuf_limit) {
-                wnow = 1;
-            }
-            break;
-    }
-
-    if (wnow) {
-        return aio_flush(interp, af);
-    }
-    return JIM_OK;
-}
-
-static int aio_cmd_isatty(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-#ifdef HAVE_ISATTY
-    AioFile *af = Jim_CmdPrivData(interp);
-    Jim_SetResultInt(interp, isatty(af->fd));
-#else
-    Jim_SetResultInt(interp, 0);
-#endif
-
-    return JIM_OK;
-}
-
-
-static int aio_cmd_flush(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-    return aio_flush(interp, af);
-}
-
-static int aio_cmd_eof(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-
-    Jim_SetResultInt(interp, !!aio_eof(af));
-    return JIM_OK;
-}
-
-static int aio_cmd_close(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-    if (argc == 3) {
-        int option = -1;
-#if defined(HAVE_SOCKETS)
-        static const char * const options[] = { "r", "w", "-nodelete", NULL };
-        enum { OPT_R, OPT_W, OPT_NODELETE };
-
-        if (Jim_GetEnum(interp, argv[2], options, &option, NULL, JIM_ERRMSG) != JIM_OK) {
-            return JIM_ERR;
-        }
-#endif
-        switch (option) {
-#if defined(HAVE_SHUTDOWN)
-            case OPT_R:
-            case OPT_W:
-                if (shutdown(af->fd, option == OPT_R ? SHUT_RD : SHUT_WR) == 0) {
-                    return JIM_OK;
-                }
-                JimAioSetError(interp, NULL);
-                return JIM_ERR;
-#endif
-#if UNIX_SOCKETS
-            case OPT_NODELETE:
-                if (af->addr_family == PF_UNIX) {
-                    af->flags |= AIO_NODELETE;
-                    break;
-                }
-
-#endif
-            default:
-                Jim_SetResultString(interp, "not supported", -1);
-                return JIM_ERR;
-        }
-    }
-
-
-    af->flags &= ~AIO_KEEPOPEN;
-
-    return Jim_DeleteCommand(interp, argv[0]);
-}
-
-static int aio_cmd_seek(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-    int orig = SEEK_SET;
-    jim_wide offset;
-
-    if (argc == 2) {
-        if (Jim_CompareStringImmediate(interp, argv[1], "start"))
-            orig = SEEK_SET;
-        else if (Jim_CompareStringImmediate(interp, argv[1], "current"))
-            orig = SEEK_CUR;
-        else if (Jim_CompareStringImmediate(interp, argv[1], "end"))
-            orig = SEEK_END;
-        else {
-            return -1;
-        }
-    }
-    if (Jim_GetWide(interp, argv[0], &offset) != JIM_OK) {
-        return JIM_ERR;
-    }
-    if (orig != SEEK_CUR || offset != 0) {
-
-        aio_flush(interp, af);
-    }
-    if (Jim_Lseek(af->fd, offset, orig) == -1) {
-        JimAioSetError(interp, af->filename);
-        return JIM_ERR;
-    }
-    if (af->readbuf) {
-        Jim_FreeNewObj(interp, af->readbuf);
-        af->readbuf = NULL;
-    }
-    af->flags &= ~AIO_EOF;
-    return JIM_OK;
-}
-
-static int aio_cmd_tell(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-
-    Jim_SetResultInt(interp, Jim_Lseek(af->fd, 0, SEEK_CUR));
-    return JIM_OK;
-}
-
-static int aio_cmd_filename(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-
-    Jim_SetResult(interp, af->filename);
-    return JIM_OK;
-}
-
-#ifdef O_NDELAY
-static int aio_cmd_ndelay(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-
-    if (argc) {
-        long nb;
-
-        if (Jim_GetLong(interp, argv[0], &nb) != JIM_OK) {
-            return JIM_ERR;
-        }
-        aio_set_nonblocking(af, nb);
-    }
-    Jim_SetResultInt(interp, (af->flags & AIO_NONBLOCK) ? 1 : 0);
-    return JIM_OK;
-}
-#endif
-
-
-#ifdef HAVE_FSYNC
-static int aio_cmd_sync(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-
-    if (aio_flush(interp, af) != JIM_OK) {
-        return JIM_ERR;
-    }
-    fsync(af->fd);
-    return JIM_OK;
-}
-#endif
-
-static int aio_cmd_buffering(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-    Jim_Obj *resultObj;
-
-    static const char * const options[] = {
-        "none",
-        "line",
-        "full",
-        NULL
-    };
-
-    if (argc) {
-        if (Jim_GetEnum(interp, argv[0], options, &af->wbuft, NULL, JIM_ERRMSG) != JIM_OK) {
-            return JIM_ERR;
-        }
-
-        if (af->wbuft == WBUF_OPT_FULL && argc == 2) {
-            long l;
-            if (Jim_GetLong(interp, argv[1], &l) != JIM_OK || l <= 0) {
-                return JIM_ERR;
-            }
-            af->wbuf_limit = l;
-        }
-
-        if (af->wbuft == WBUF_OPT_NONE) {
-            if (aio_flush(interp, af) != JIM_OK) {
-                return JIM_ERR;
-            }
-        }
-
-    }
-
-    resultObj = Jim_NewListObj(interp, NULL, 0);
-    Jim_ListAppendElement(interp, resultObj, Jim_NewStringObj(interp, options[af->wbuft], -1));
-    if (af->wbuft == WBUF_OPT_FULL) {
-        Jim_ListAppendElement(interp, resultObj, Jim_NewIntObj(interp, af->wbuf_limit));
-    }
-    Jim_SetResult(interp, resultObj);
-
-    return JIM_OK;
-}
-
-static int aio_cmd_translation(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    enum {OPT_BINARY, OPT_TEXT};
-    static const char * const options[] = {
-        "binary",
-        "text",
-        NULL
-    };
-    int opt;
-
-    if (Jim_GetEnum(interp, argv[0], options, &opt, NULL, JIM_ERRMSG) != JIM_OK) {
-            return JIM_ERR;
-    }
-#if defined(Jim_SetMode)
-    else {
-        AioFile *af = Jim_CmdPrivData(interp);
-        Jim_SetMode(af->fd, opt == OPT_BINARY ? O_BINARY : O_TEXT);
-    }
-#endif
-    return JIM_OK;
-}
-
-static int aio_cmd_readsize(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-
-    if (argc) {
-        long l;
-        if (Jim_GetLong(interp, argv[0], &l) != JIM_OK || l <= 0) {
-            return JIM_ERR;
-        }
-        af->rbuf_len = l;
-        if (af->rbuf) {
-            af->rbuf = Jim_Realloc(af->rbuf, af->rbuf_len);
-        }
-    }
-    Jim_SetResultInt(interp, af->rbuf_len);
-
-    return JIM_OK;
-}
-
-#ifdef jim_ext_eventloop
-static int aio_cmd_timeout(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-#ifdef HAVE_SELECT
-    AioFile *af = Jim_CmdPrivData(interp);
-    if (argc == 1) {
-        if (Jim_GetLong(interp, argv[0], &af->timeout) != JIM_OK) {
-            return JIM_ERR;
-        }
-    }
-    Jim_SetResultInt(interp, af->timeout);
-    return JIM_OK;
-#else
-    Jim_SetResultString(interp, "timeout not supported", -1);
-    return JIM_ERR;
-#endif
-}
-
-static int aio_eventinfo(Jim_Interp *interp, AioFile * af, unsigned mask,
-    int argc, Jim_Obj * const *argv)
-{
-    if (argc == 0) {
-
-        Jim_Obj *objPtr = Jim_FindFileHandler(interp, af->fd, mask);
-        if (objPtr) {
-            Jim_SetResult(interp, objPtr);
-        }
-        return JIM_OK;
-    }
-
-
-    Jim_DeleteFileHandler(interp, af->fd, mask);
-
-
-    if (Jim_Length(argv[0])) {
-        Jim_CreateScriptFileHandler(interp, af->fd, mask, argv[0]);
-    }
-
-    return JIM_OK;
-}
-
-static int aio_cmd_readable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-
-    return aio_eventinfo(interp, af, JIM_EVENT_READABLE, argc, argv);
-}
-
-static int aio_cmd_writable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-
-    return aio_eventinfo(interp, af, JIM_EVENT_WRITABLE, argc, argv);
-}
-
-static int aio_cmd_onexception(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-
-    return aio_eventinfo(interp, af, JIM_EVENT_EXCEPTION, argc, argv);
-}
-#endif
-
-#if defined(jim_ext_file) && defined(Jim_FileStat)
-static int aio_cmd_stat(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    jim_stat_t sb;
-    AioFile *af = Jim_CmdPrivData(interp);
-
-    if (Jim_FileStat(af->fd, &sb) == -1) {
-        JimAioSetError(interp, NULL);
-        return JIM_ERR;
-    }
-    return Jim_FileStoreStatData(interp, argc == 0 ? NULL : argv[0], &sb);
-}
-#endif
-
-
-
-
-static const jim_subcmd_type aio_command_table[] = {
-    {   "read",
-        "?-nonewline|len?",
-        aio_cmd_read,
-        0,
-        2,
-
-    },
-    {   "copyto",
-        "handle ?size?",
-        aio_cmd_copy,
-        1,
-        2,
-
-    },
-    {   "getfd",
-        NULL,
-        aio_cmd_getfd,
-        0,
-        0,
-
-    },
-    {   "gets",
-        "?var?",
-        aio_cmd_gets,
-        0,
-        1,
-
-    },
-    {   "puts",
-        "?-nonewline? str",
-        aio_cmd_puts,
-        1,
-        2,
-
-    },
-    {   "isatty",
-        NULL,
-        aio_cmd_isatty,
-        0,
-        0,
-
-    },
-    {   "flush",
-        NULL,
-        aio_cmd_flush,
-        0,
-        0,
-
-    },
-    {   "eof",
-        NULL,
-        aio_cmd_eof,
-        0,
-        0,
-
-    },
-    {   "close",
-        "?r(ead)|w(rite)?",
-        aio_cmd_close,
-        0,
-        1,
-        JIM_MODFLAG_FULLARGV,
-
-    },
-    {   "seek",
-        "offset ?start|current|end",
-        aio_cmd_seek,
-        1,
-        2,
-
-    },
-    {   "tell",
-        NULL,
-        aio_cmd_tell,
-        0,
-        0,
-
-    },
-    {   "filename",
-        NULL,
-        aio_cmd_filename,
-        0,
-        0,
-
-    },
-#ifdef O_NDELAY
-    {   "ndelay",
-        "?0|1?",
-        aio_cmd_ndelay,
-        0,
-        1,
-
-    },
-#endif
-#ifdef HAVE_FSYNC
-    {   "sync",
-        NULL,
-        aio_cmd_sync,
-        0,
-        0,
-
-    },
-#endif
-    {   "buffering",
-        "?none|line|full? ?size?",
-        aio_cmd_buffering,
-        0,
-        2,
-
-    },
-    {   "translation",
-        "binary|text",
-        aio_cmd_translation,
-        1,
-        1,
-
-    },
-    {   "readsize",
-        "?size?",
-        aio_cmd_readsize,
-        0,
-        1,
-
-    },
-#if defined(jim_ext_file) && defined(Jim_FileStat)
-    {   "stat",
-        "?var?",
-        aio_cmd_stat,
-        0,
-        1,
-
-    },
-#endif
-#ifdef jim_ext_eventloop
-    {   "readable",
-        "?readable-script?",
-        aio_cmd_readable,
-        0,
-        1,
-
-    },
-    {   "writable",
-        "?writable-script?",
-        aio_cmd_writable,
-        0,
-        1,
-
-    },
-    {   "onexception",
-        "?exception-script?",
-        aio_cmd_onexception,
-        0,
-        1,
-
-    },
-    {   "timeout",
-        "?ms?",
-        aio_cmd_timeout,
-        0,
-        1,
-
-    },
-#endif
-    { NULL }
-};
-
-static int JimAioSubCmdProc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return Jim_CallSubCmd(interp, Jim_ParseSubCmd(interp, aio_command_table, argc, argv), argc, argv);
-}
-
-static int parse_posix_open_mode(Jim_Interp *interp, Jim_Obj *modeObj)
-{
-    int i;
-    int flags = 0;
-    #ifndef O_NOCTTY
-
-        #define O_NOCTTY 0
-    #endif
-    static const char * const modetypes[] = {
-        "RDONLY", "WRONLY", "RDWR", "APPEND", "BINARY", "CREAT", "EXCL", "NOCTTY", "TRUNC", NULL
-    };
-    static const int modeflags[] = {
-        O_RDONLY, O_WRONLY, O_RDWR, O_APPEND, 0, O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC,
-    };
-
-    for (i = 0; i < Jim_ListLength(interp, modeObj); i++) {
-        int opt;
-        Jim_Obj *objPtr = Jim_ListGetIndex(interp, modeObj, i);
-        if (Jim_GetEnum(interp, objPtr, modetypes, &opt, "access mode", JIM_ERRMSG) != JIM_OK) {
-            return -1;
-        }
-        flags |= modeflags[opt];
-    }
-    return flags;
-}
-
-static int parse_open_mode(Jim_Interp *interp, Jim_Obj *filenameObj, Jim_Obj *modeObj)
-{
-
-    int flags;
-    const char *mode = Jim_String(modeObj);
-    if (*mode == 'R' || *mode == 'W') {
-        return parse_posix_open_mode(interp, modeObj);
-    }
-    if (*mode == 'r') {
-        flags = O_RDONLY;
-    }
-    else if (*mode == 'w') {
-        flags = O_WRONLY | O_CREAT | O_TRUNC;
-    }
-    else if (*mode == 'a') {
-        flags = O_WRONLY | O_CREAT | O_APPEND;
-    }
-    else {
-        Jim_SetResultFormatted(interp, "%s: invalid open mode '%s'", Jim_String(filenameObj), mode);
-        return -1;
-    }
-    mode++;
-
-    if (*mode == 'b') {
-#ifdef O_BINARY
-        flags |= O_BINARY;
-#endif
-        mode++;
-    }
-
-    if (*mode == 't') {
-#ifdef O_TEXT
-        flags |= O_TEXT;
-#endif
-        mode++;
-    }
-
-    if (*mode == '+') {
-        mode++;
-
-        flags &= ~(O_RDONLY | O_WRONLY);
-        flags |= O_RDWR;
-    }
-
-    if (*mode == 'x') {
-        mode++;
-#ifdef O_EXCL
-        flags |= O_EXCL;
-#endif
-    }
-
-    if (*mode == 'F') {
-        mode++;
-#ifdef O_LARGEFILE
-        flags |= O_LARGEFILE;
-#endif
-    }
-
-    if (*mode == 'e') {
-
-        mode++;
-    }
-    return flags;
-}
-
-static int JimAioOpenCommand(Jim_Interp *interp, int argc,
-        Jim_Obj *const *argv)
-{
-    int openflags;
-    const char *filename;
-    int fd = -1;
-    int n = 0;
-    int flags = 0;
-
-    if (argc > 2 && Jim_CompareStringImmediate(interp, argv[2], "-noclose")) {
-        flags = AIO_KEEPOPEN;
-        n++;
-    }
-    if (argc < 2 || argc > 3 + n) {
-        Jim_WrongNumArgs(interp, 1, argv, "filename ?-noclose? ?mode?");
-        return JIM_ERR;
-    }
-
-    filename = Jim_String(argv[1]);
-
-#ifdef jim_ext_tclcompat
-    {
-
-
-        if (*filename == '|') {
-            Jim_Obj *evalObj[3];
-            int i = 0;
-
-            evalObj[i++] = Jim_NewStringObj(interp, "::popen", -1);
-            evalObj[i++] = Jim_NewStringObj(interp, filename + 1, -1);
-            if (argc == 3 + n) {
-                evalObj[i++] = argv[2 + n];
-            }
-
-            return Jim_EvalObjVector(interp, i, evalObj);
-        }
-    }
-#endif
-    if (argc == 3 + n) {
-        openflags = parse_open_mode(interp, argv[1], argv[2 + n]);
-        if (openflags == -1) {
-            return JIM_ERR;
-        }
-    }
-    else {
-        openflags = O_RDONLY;
-    }
-    fd = open(filename, openflags, 0666);
-    if (fd < 0) {
-        JimAioSetError(interp, argv[1]);
-        return JIM_ERR;
-    }
-
-    return JimMakeChannel(interp, fd, argv[1], "aio.handle%ld", 0, flags) ? JIM_OK : JIM_ERR;
-}
-
-
-static AioFile *JimMakeChannel(Jim_Interp *interp, int fd, Jim_Obj *filename,
-    const char *hdlfmt, int family, int flags)
-{
-    AioFile *af;
-    char buf[AIO_CMD_LEN];
-    Jim_Obj *cmdname;
-
-    snprintf(buf, sizeof(buf), hdlfmt, Jim_GetId(interp));
-    cmdname = Jim_NewStringObj(interp, buf, -1);
-    if (!filename) {
-        filename = cmdname;
-    }
-    Jim_IncrRefCount(filename);
-
-
-    af = Jim_Alloc(sizeof(*af));
-    memset(af, 0, sizeof(*af));
-    af->filename = filename;
-    af->fd = fd;
-    af->addr_family = family;
-    af->fops = &stdio_fops;
-    af->ssl = NULL;
-    if (flags & AIO_WBUF_NONE) {
-        af->wbuft = WBUF_OPT_NONE;
-    }
-    else {
-#ifdef HAVE_ISATTY
-        af->wbuft = isatty(af->fd) ? WBUF_OPT_LINE : WBUF_OPT_FULL;
-#else
-        af->wbuft = WBUF_OPT_FULL;
-#endif
-    }
-
-#ifdef FD_CLOEXEC
-    if ((flags & AIO_KEEPOPEN) == 0) {
-        (void)fcntl(af->fd, F_SETFD, FD_CLOEXEC);
-    }
-#endif
-    aio_set_nonblocking(af, !!(flags & AIO_NONBLOCK));
-
-    af->flags |= flags;
-
-    af->writebuf = Jim_NewStringObj(interp, NULL, 0);
-    Jim_IncrRefCount(af->writebuf);
-    af->wbuf_limit = AIO_DEFAULT_WBUF_LIMIT;
-    af->rbuf_len = AIO_DEFAULT_RBUF_LEN;
-
-
-    Jim_CreateCommand(interp, buf, JimAioSubCmdProc, af, JimAioDelProc);
-
-    Jim_SetResult(interp, Jim_MakeGlobalNamespaceName(interp, cmdname));
-
-    return af;
-}
-
-#if defined(HAVE_PIPE) || (defined(HAVE_SOCKETPAIR) && UNIX_SOCKETS) || defined(HAVE_OPENPTY)
-static int JimMakeChannelPair(Jim_Interp *interp, int p[2], Jim_Obj *filename,
-    const char *hdlfmt, int family, int flags)
-{
-    if (JimMakeChannel(interp, p[0], filename, hdlfmt, family, flags)) {
-        Jim_Obj *objPtr = Jim_NewListObj(interp, NULL, 0);
-        Jim_ListAppendElement(interp, objPtr, Jim_GetResult(interp));
-        if (JimMakeChannel(interp, p[1], filename, hdlfmt, family, flags)) {
-            Jim_ListAppendElement(interp, objPtr, Jim_GetResult(interp));
-            Jim_SetResult(interp, objPtr);
-            return JIM_OK;
-        }
-    }
-
-
-    close(p[0]);
-    close(p[1]);
-    JimAioSetError(interp, NULL);
-    return JIM_ERR;
-}
-#endif
-
-#ifdef HAVE_PIPE
-static int JimCreatePipe(Jim_Interp *interp, Jim_Obj *filenameObj, int flags)
-{
-    int p[2];
-
-    if (pipe(p) != 0) {
-        JimAioSetError(interp, NULL);
-        return JIM_ERR;
-    }
-
-    return JimMakeChannelPair(interp, p, filenameObj, "aio.pipe%ld", 0, flags);
-}
-
-
-static int JimAioPipeCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    if (argc != 1) {
-        Jim_WrongNumArgs(interp, 1, argv, "");
-        return JIM_ERR;
-    }
-    return JimCreatePipe(interp, argv[0], 0);
-}
-#endif
-
-#ifdef HAVE_OPENPTY
-static int JimAioOpenPtyCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int p[2];
-    char path[MAXPATHLEN];
-
-    if (argc != 1) {
-        Jim_WrongNumArgs(interp, 1, argv, "");
-        return JIM_ERR;
-    }
-
-    if (openpty(&p[0], &p[1], path, NULL, NULL) != 0) {
-        JimAioSetError(interp, NULL);
-        return JIM_ERR;
-    }
-
-
-    return JimMakeChannelPair(interp, p, Jim_NewStringObj(interp, path, -1), "aio.pty%ld", 0, 0);
-    return JimMakeChannelPair(interp, p, Jim_NewStringObj(interp, path, -1), "aio.pty%ld", 0, 0);
-}
-#endif
-
-
-
-int Jim_aioInit(Jim_Interp *interp)
-{
-    if (Jim_PackageProvide(interp, "aio", "1.0", JIM_ERRMSG))
-        return JIM_ERR;
-
-#if defined(JIM_SSL)
-    Jim_CreateCommand(interp, "load_ssl_certs", JimAioLoadSSLCertsCommand, NULL, NULL);
-#endif
-
-    Jim_CreateCommand(interp, "open", JimAioOpenCommand, NULL, NULL);
-#ifdef HAVE_SOCKETS
-    Jim_CreateCommand(interp, "socket", JimAioSockCommand, NULL, NULL);
-#endif
-#ifdef HAVE_PIPE
-    Jim_CreateCommand(interp, "pipe", JimAioPipeCommand, NULL, NULL);
-#endif
-
-
-    JimMakeChannel(interp, fileno(stdin), NULL, "stdin", 0, AIO_KEEPOPEN);
-    JimMakeChannel(interp, fileno(stdout), NULL, "stdout", 0, AIO_KEEPOPEN);
-    JimMakeChannel(interp, fileno(stderr), NULL, "stderr", 0, AIO_KEEPOPEN | AIO_WBUF_NONE);
-
-    return JIM_OK;
-}
-
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-
-
-#ifdef HAVE_DIRENT_H
-#include <dirent.h>
-#endif
-
-int Jim_ReaddirCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    const char *dirPath;
-    DIR *dirPtr;
-    struct dirent *entryPtr;
-    int nocomplain = 0;
-
-    if (argc == 3 && Jim_CompareStringImmediate(interp, argv[1], "-nocomplain")) {
-        nocomplain = 1;
-    }
-    if (argc != 2 && !nocomplain) {
-        Jim_WrongNumArgs(interp, 1, argv, "?-nocomplain? dirPath");
-        return JIM_ERR;
-    }
-
-    dirPath = Jim_String(argv[1 + nocomplain]);
-
-    dirPtr = opendir(dirPath);
-    if (dirPtr == NULL) {
-        if (nocomplain) {
-            return JIM_OK;
-        }
-        Jim_SetResultString(interp, strerror(errno), -1);
-        return JIM_ERR;
-    }
-    else {
-        Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
-
-        while ((entryPtr = readdir(dirPtr)) != NULL) {
-            if (entryPtr->d_name[0] == '.') {
-                if (entryPtr->d_name[1] == '\0') {
-                    continue;
-                }
-                if ((entryPtr->d_name[1] == '.') && (entryPtr->d_name[2] == '\0'))
-                    continue;
-            }
-            Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, entryPtr->d_name, -1));
-        }
-        closedir(dirPtr);
-
-        Jim_SetResult(interp, listObj);
-
-        return JIM_OK;
-    }
-}
-
-int Jim_readdirInit(Jim_Interp *interp)
-{
-    Jim_PackageProvideCheck(interp, "readdir");
-    Jim_CreateCommand(interp, "readdir", Jim_ReaddirCmd, NULL, NULL);
-    return JIM_OK;
-}
-
-#include <stdlib.h>
-#include <string.h>
-
-#if defined(JIM_REGEXP)
-#else
-    #include <regex.h>
-    #define jim_regcomp regcomp
-    #define jim_regexec regexec
-    #define jim_regerror regerror
-    #define jim_regfree regfree
-#endif
-
-static void FreeRegexpInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    jim_regfree(objPtr->internalRep.ptrIntValue.ptr);
-    Jim_Free(objPtr->internalRep.ptrIntValue.ptr);
-}
-
-static const Jim_ObjType regexpObjType = {
-    "regexp",
-    FreeRegexpInternalRep,
-    NULL,
-    NULL,
-    JIM_TYPE_NONE
-};
-
-static regex_t *SetRegexpFromAny(Jim_Interp *interp, Jim_Obj *objPtr, unsigned flags)
-{
-    regex_t *compre;
-    const char *pattern;
-    int ret;
-
-
-    if (objPtr->typePtr == &regexpObjType &&
-        objPtr->internalRep.ptrIntValue.ptr && objPtr->internalRep.ptrIntValue.int1 == flags) {
-
-        return objPtr->internalRep.ptrIntValue.ptr;
-    }
-
-
-
-
-    pattern = Jim_String(objPtr);
-    compre = Jim_Alloc(sizeof(regex_t));
-
-    if ((ret = jim_regcomp(compre, pattern, REG_EXTENDED | flags)) != 0) {
-        char buf[100];
-
-        jim_regerror(ret, compre, buf, sizeof(buf));
-        Jim_SetResultFormatted(interp, "couldn't compile regular expression pattern: %s", buf);
-        jim_regfree(compre);
-        Jim_Free(compre);
-        return NULL;
-    }
-
-    Jim_FreeIntRep(interp, objPtr);
-
-    objPtr->typePtr = &regexpObjType;
-    objPtr->internalRep.ptrIntValue.int1 = flags;
-    objPtr->internalRep.ptrIntValue.ptr = compre;
-
-    return compre;
-}
-
-int Jim_RegexpCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int opt_indices = 0;
-    int opt_all = 0;
-    int opt_inline = 0;
-    regex_t *regex;
-    int match, i, j;
-    int offset = 0;
-    regmatch_t *pmatch = NULL;
-    int source_len;
-    int result = JIM_OK;
-    const char *pattern;
-    const char *source_str;
-    int num_matches = 0;
-    int num_vars;
-    Jim_Obj *resultListObj = NULL;
-    int regcomp_flags = 0;
-    int eflags = 0;
-    int option;
-    enum {
-        OPT_INDICES,  OPT_NOCASE, OPT_LINE, OPT_ALL, OPT_INLINE, OPT_START, OPT_END
-    };
-    static const char * const options[] = {
-        "-indices", "-nocase", "-line", "-all", "-inline", "-start", "--", NULL
-    };
-
-    if (argc < 3) {
-      wrongNumArgs:
-        Jim_WrongNumArgs(interp, 1, argv,
-            "?-switch ...? exp string ?matchVar? ?subMatchVar ...?");
-        return JIM_ERR;
-    }
-
-    for (i = 1; i < argc; i++) {
-        const char *opt = Jim_String(argv[i]);
-
-        if (*opt != '-') {
-            break;
-        }
-        if (Jim_GetEnum(interp, argv[i], options, &option, "switch", JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK) {
-            return JIM_ERR;
-        }
-        if (option == OPT_END) {
-            i++;
-            break;
-        }
-        switch (option) {
-            case OPT_INDICES:
-                opt_indices = 1;
-                break;
-
-            case OPT_NOCASE:
-                regcomp_flags |= REG_ICASE;
-                break;
-
-            case OPT_LINE:
-                regcomp_flags |= REG_NEWLINE;
-                break;
-
-            case OPT_ALL:
-                opt_all = 1;
-                break;
-
-            case OPT_INLINE:
-                opt_inline = 1;
-                break;
-
-            case OPT_START:
-                if (++i == argc) {
-                    goto wrongNumArgs;
-                }
-                if (Jim_GetIndex(interp, argv[i], &offset) != JIM_OK) {
-                    return JIM_ERR;
-                }
-                break;
-        }
-    }
-    if (argc - i < 2) {
-        goto wrongNumArgs;
-    }
-
-    regex = SetRegexpFromAny(interp, argv[i], regcomp_flags);
-    if (!regex) {
-        return JIM_ERR;
-    }
-
-    pattern = Jim_String(argv[i]);
-    source_str = Jim_GetString(argv[i + 1], &source_len);
-
-    num_vars = argc - i - 2;
-
-    if (opt_inline) {
-        if (num_vars) {
-            Jim_SetResultString(interp, "regexp match variables not allowed when using -inline",
-                -1);
-            result = JIM_ERR;
-            goto done;
-        }
-        num_vars = regex->re_nsub + 1;
-    }
-
-    pmatch = Jim_Alloc((num_vars + 1) * sizeof(*pmatch));
-
-    if (offset) {
-        if (offset < 0) {
-            offset += source_len + 1;
-        }
-        if (offset > source_len) {
-            source_str += source_len;
-        }
-        else if (offset > 0) {
-            source_str += utf8_index(source_str, offset);
-        }
-        eflags |= REG_NOTBOL;
-    }
-
-    if (opt_inline) {
-        resultListObj = Jim_NewListObj(interp, NULL, 0);
-    }
-
-  next_match:
-    match = jim_regexec(regex, source_str, num_vars + 1, pmatch, eflags);
-    if (match >= REG_BADPAT) {
-        char buf[100];
-
-        jim_regerror(match, regex, buf, sizeof(buf));
-        Jim_SetResultFormatted(interp, "error while matching pattern: %s", buf);
-        result = JIM_ERR;
-        goto done;
-    }
-
-    if (match == REG_NOMATCH) {
-        goto done;
-    }
-
-    num_matches++;
-
-    if (opt_all && !opt_inline) {
-
-        goto try_next_match;
-    }
-
-
-    j = 0;
-    for (i += 2; opt_inline ? j < num_vars : i < argc; i++, j++) {
-        Jim_Obj *resultObj;
-
-        if (opt_indices) {
-            resultObj = Jim_NewListObj(interp, NULL, 0);
-        }
-        else {
-            resultObj = Jim_NewStringObj(interp, "", 0);
-        }
-
-        if (pmatch[j].rm_so == -1) {
-            if (opt_indices) {
-                Jim_ListAppendElement(interp, resultObj, Jim_NewIntObj(interp, -1));
-                Jim_ListAppendElement(interp, resultObj, Jim_NewIntObj(interp, -1));
-            }
-        }
-        else {
-            if (opt_indices) {
-
-                int so = utf8_strlen(source_str, pmatch[j].rm_so);
-                int eo = utf8_strlen(source_str, pmatch[j].rm_eo);
-                Jim_ListAppendElement(interp, resultObj, Jim_NewIntObj(interp, offset + so));
-                Jim_ListAppendElement(interp, resultObj, Jim_NewIntObj(interp, offset + eo - 1));
-            }
-            else {
-                Jim_AppendString(interp, resultObj, source_str + pmatch[j].rm_so, pmatch[j].rm_eo - pmatch[j].rm_so);
-            }
-        }
-
-        if (opt_inline) {
-            Jim_ListAppendElement(interp, resultListObj, resultObj);
-        }
-        else {
-
-            result = Jim_SetVariable(interp, argv[i], resultObj);
-
-            if (result != JIM_OK) {
-                Jim_FreeObj(interp, resultObj);
-                break;
-            }
-        }
-    }
-
-  try_next_match:
-    if (opt_all && (pattern[0] != '^' || (regcomp_flags & REG_NEWLINE)) && *source_str) {
-        if (pmatch[0].rm_eo) {
-            offset += utf8_strlen(source_str, pmatch[0].rm_eo);
-            source_str += pmatch[0].rm_eo;
-        }
-        else {
-            source_str++;
-            offset++;
-        }
-        if (*source_str) {
-            eflags = REG_NOTBOL;
-            goto next_match;
-        }
-    }
-
-  done:
-    if (result == JIM_OK) {
-        if (opt_inline) {
-            Jim_SetResult(interp, resultListObj);
-        }
-        else {
-            Jim_SetResultInt(interp, num_matches);
-        }
-    }
-
-    Jim_Free(pmatch);
-    return result;
-}
-
-#define MAX_SUB_MATCHES 50
-
-int Jim_RegsubCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int regcomp_flags = 0;
-    int regexec_flags = 0;
-    int opt_all = 0;
-    int opt_command = 0;
-    int offset = 0;
-    regex_t *regex;
-    const char *p;
-    int result = JIM_OK;
-    regmatch_t pmatch[MAX_SUB_MATCHES + 1];
-    int num_matches = 0;
-
-    int i, j, n;
-    Jim_Obj *varname;
-    Jim_Obj *resultObj;
-    Jim_Obj *cmd_prefix = NULL;
-    Jim_Obj *regcomp_obj = NULL;
-    const char *source_str;
-    int source_len;
-    const char *replace_str = NULL;
-    int replace_len;
-    const char *pattern;
-    int option;
-    enum {
-        OPT_NOCASE, OPT_LINE, OPT_ALL, OPT_START, OPT_COMMAND, OPT_END
-    };
-    static const char * const options[] = {
-        "-nocase", "-line", "-all", "-start", "-command", "--", NULL
-    };
-
-    if (argc < 4) {
-      wrongNumArgs:
-        Jim_WrongNumArgs(interp, 1, argv,
-            "?-switch ...? exp string subSpec ?varName?");
-        return JIM_ERR;
-    }
-
-    for (i = 1; i < argc; i++) {
-        const char *opt = Jim_String(argv[i]);
-
-        if (*opt != '-') {
-            break;
-        }
-        if (Jim_GetEnum(interp, argv[i], options, &option, "switch", JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK) {
-            return JIM_ERR;
-        }
-        if (option == OPT_END) {
-            i++;
-            break;
-        }
-        switch (option) {
-            case OPT_NOCASE:
-                regcomp_flags |= REG_ICASE;
-                break;
-
-            case OPT_LINE:
-                regcomp_flags |= REG_NEWLINE;
-                break;
-
-            case OPT_ALL:
-                opt_all = 1;
-                break;
-
-            case OPT_START:
-                if (++i == argc) {
-                    goto wrongNumArgs;
-                }
-                if (Jim_GetIndex(interp, argv[i], &offset) != JIM_OK) {
-                    return JIM_ERR;
-                }
-                break;
-
-            case OPT_COMMAND:
-                opt_command = 1;
-                break;
-        }
-    }
-    if (argc - i != 3 && argc - i != 4) {
-        goto wrongNumArgs;
-    }
-
-
-    regcomp_obj = Jim_DuplicateObj(interp, argv[i]);
-	Jim_IncrRefCount(regcomp_obj);
-    regex = SetRegexpFromAny(interp, regcomp_obj, regcomp_flags);
-    if (!regex) {
-		Jim_DecrRefCount(interp, regcomp_obj);
-        return JIM_ERR;
-    }
-    pattern = Jim_String(argv[i]);
-
-    source_str = Jim_GetString(argv[i + 1], &source_len);
-    if (opt_command) {
-        cmd_prefix = argv[i + 2];
-        if (Jim_ListLength(interp, cmd_prefix) == 0) {
-            Jim_SetResultString(interp, "command prefix must be a list of at least one element", -1);
-			Jim_DecrRefCount(interp, regcomp_obj);
-            return JIM_ERR;
-        }
-        Jim_IncrRefCount(cmd_prefix);
-    }
-    else {
-        replace_str = Jim_GetString(argv[i + 2], &replace_len);
-    }
-    varname = argv[i + 3];
-
-
-    resultObj = Jim_NewStringObj(interp, "", 0);
-
-    if (offset) {
-        if (offset < 0) {
-            offset += source_len + 1;
-        }
-        if (offset > source_len) {
-            offset = source_len;
-        }
-        else if (offset < 0) {
-            offset = 0;
-        }
-    }
-
-    offset = utf8_index(source_str, offset);
-
-
-    Jim_AppendString(interp, resultObj, source_str, offset);
-
-
-    n = source_len - offset;
-    p = source_str + offset;
-    do {
-        int match = jim_regexec(regex, p, MAX_SUB_MATCHES, pmatch, regexec_flags);
-
-        if (match >= REG_BADPAT) {
-            char buf[100];
-
-            jim_regerror(match, regex, buf, sizeof(buf));
-            Jim_SetResultFormatted(interp, "error while matching pattern: %s", buf);
-            return JIM_ERR;
-        }
-        if (match == REG_NOMATCH) {
-            break;
-        }
-
-        num_matches++;
-
-        Jim_AppendString(interp, resultObj, p, pmatch[0].rm_so);
-
-        if (opt_command) {
-
-            Jim_Obj *cmdListObj = Jim_DuplicateObj(interp, cmd_prefix);
-            for (j = 0; j < MAX_SUB_MATCHES; j++) {
-                if (pmatch[j].rm_so == -1) {
-                    break;
-                }
-                else {
-                    Jim_Obj *srcObj = Jim_NewStringObj(interp, p + pmatch[j].rm_so, pmatch[j].rm_eo - pmatch[j].rm_so);
-                    Jim_ListAppendElement(interp, cmdListObj, srcObj);
-                }
-            }
-            Jim_IncrRefCount(cmdListObj);
-
-            result = Jim_EvalObj(interp, cmdListObj);
-            Jim_DecrRefCount(interp, cmdListObj);
-            if (result != JIM_OK) {
-                goto cmd_error;
-            }
-            Jim_AppendString(interp, resultObj, Jim_String(Jim_GetResult(interp)), -1);
-        }
-        else {
-
-            for (j = 0; j < replace_len; j++) {
-                int idx;
-                int c = replace_str[j];
-
-                if (c == '&') {
-                    idx = 0;
-                }
-                else if (c == '\\' && j < replace_len) {
-                    c = replace_str[++j];
-                    if ((c >= '0') && (c <= '9')) {
-                        idx = c - '0';
-                    }
-                    else if ((c == '\\') || (c == '&')) {
-                        Jim_AppendString(interp, resultObj, replace_str + j, 1);
-                        continue;
-                    }
-                    else {
-                        Jim_AppendString(interp, resultObj, replace_str + j - 1, (j == replace_len) ? 1 : 2);
-                        continue;
-                    }
-                }
-                else {
-                    Jim_AppendString(interp, resultObj, replace_str + j, 1);
-                    continue;
-                }
-                if ((idx < MAX_SUB_MATCHES) && pmatch[idx].rm_so != -1 && pmatch[idx].rm_eo != -1) {
-                    Jim_AppendString(interp, resultObj, p + pmatch[idx].rm_so,
-                        pmatch[idx].rm_eo - pmatch[idx].rm_so);
-                }
-            }
-        }
-
-        p += pmatch[0].rm_eo;
-        n -= pmatch[0].rm_eo;
-
-
-        if (!opt_all || n == 0) {
-            break;
-        }
-
-
-        if ((regcomp_flags & REG_NEWLINE) == 0 && pattern[0] == '^') {
-            break;
-        }
-
-
-        if (pattern[0] == '\0' && n) {
-
-            Jim_AppendString(interp, resultObj, p, 1);
-            p++;
-            n--;
-        }
-
-        if (pmatch[0].rm_eo == pmatch[0].rm_so) {
-
-            regexec_flags = REG_NOTBOL;
-        }
-        else {
-            regexec_flags = 0;
-        }
-
-    } while (n);
-
-    Jim_AppendString(interp, resultObj, p, -1);
-
-cmd_error:
-    if (result == JIM_OK) {
-
-        if (argc - i == 4) {
-            result = Jim_SetVariable(interp, varname, resultObj);
-
-            if (result == JIM_OK) {
-                Jim_SetResultInt(interp, num_matches);
-            }
-            else {
-                Jim_FreeObj(interp, resultObj);
-            }
-        }
-        else {
-            Jim_SetResult(interp, resultObj);
-            result = JIM_OK;
-        }
-    }
-    else {
-        Jim_FreeObj(interp, resultObj);
-    }
-
-    if (opt_command) {
-        Jim_DecrRefCount(interp, cmd_prefix);
-    }
-
-	Jim_DecrRefCount(interp, regcomp_obj);
-
-    return result;
-}
-
-int Jim_regexpInit(Jim_Interp *interp)
-{
-    Jim_PackageProvideCheck(interp, "regexp");
-    Jim_CreateCommand(interp, "regexp", Jim_RegexpCmd, NULL, NULL);
-    Jim_CreateCommand(interp, "regsub", Jim_RegsubCmd, NULL, NULL);
-    return JIM_OK;
-}
-
-#include <limits.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <errno.h>
-
-
-#ifdef HAVE_UTIMES
-#include <sys/time.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#elif defined(_MSC_VER)
-#include <direct.h>
-#define F_OK 0
-#define W_OK 2
-#define R_OK 4
-#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
-#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
-#endif
-
-#if defined(__MINGW32__) || defined(__MSYS__) || defined(_MSC_VER)
-#define ISWINDOWS 1
-
-#undef HAVE_SYMLINK
-#else
-#define ISWINDOWS 0
-#endif
-
-
-#if defined(HAVE_STRUCT_STAT_ST_MTIMESPEC)
-    #define STAT_MTIME_US(STAT) ((STAT).st_mtimespec.tv_sec * 1000000ll + (STAT).st_mtimespec.tv_nsec / 1000)
-#elif defined(HAVE_STRUCT_STAT_ST_MTIM)
-    #define STAT_MTIME_US(STAT) ((STAT).st_mtim.tv_sec * 1000000ll + (STAT).st_mtim.tv_nsec / 1000)
-#endif
-
-
-static void JimFixPath(char *path)
-{
-    if (ISWINDOWS) {
-
-        char *p = path;
-        while ((p = strchr(p, '\\')) != NULL) {
-            *p++ = '/';
-        }
-    }
-}
-
-
-static const char *JimGetFileType(int mode)
-{
-    if (S_ISREG(mode)) {
-        return "file";
-    }
-    else if (S_ISDIR(mode)) {
-        return "directory";
-    }
-#ifdef S_ISCHR
-    else if (S_ISCHR(mode)) {
-        return "characterSpecial";
-    }
-#endif
-#ifdef S_ISBLK
-    else if (S_ISBLK(mode)) {
-        return "blockSpecial";
-    }
-#endif
-#ifdef S_ISFIFO
-    else if (S_ISFIFO(mode)) {
-        return "fifo";
-    }
-#endif
-#ifdef S_ISLNK
-    else if (S_ISLNK(mode)) {
-        return "link";
-    }
-#endif
-#ifdef S_ISSOCK
-    else if (S_ISSOCK(mode)) {
-        return "socket";
-    }
-#endif
-    return "unknown";
-}
-
-static void AppendStatElement(Jim_Interp *interp, Jim_Obj *listObj, const char *key, jim_wide value)
-{
-    Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, key, -1));
-    Jim_ListAppendElement(interp, listObj, Jim_NewIntObj(interp, value));
-}
-
-int Jim_FileStoreStatData(Jim_Interp *interp, Jim_Obj *varName, const jim_stat_t *sb)
-{
-
-    Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
-
-    AppendStatElement(interp, listObj, "dev", sb->st_dev);
-    AppendStatElement(interp, listObj, "ino", sb->st_ino);
-    AppendStatElement(interp, listObj, "mode", sb->st_mode);
-    AppendStatElement(interp, listObj, "nlink", sb->st_nlink);
-    AppendStatElement(interp, listObj, "uid", sb->st_uid);
-    AppendStatElement(interp, listObj, "gid", sb->st_gid);
-    AppendStatElement(interp, listObj, "size", sb->st_size);
-    AppendStatElement(interp, listObj, "atime", sb->st_atime);
-    AppendStatElement(interp, listObj, "mtime", sb->st_mtime);
-    AppendStatElement(interp, listObj, "ctime", sb->st_ctime);
-#ifdef STAT_MTIME_US
-    AppendStatElement(interp, listObj, "mtimeus", STAT_MTIME_US(*sb));
-#endif
-    Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, "type", -1));
-    Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, JimGetFileType((int)sb->st_mode), -1));
-
-
-    if (varName) {
-        Jim_Obj *objPtr;
-        objPtr = Jim_GetVariable(interp, varName, JIM_NONE);
-
-        if (objPtr) {
-            Jim_Obj *objv[2];
-
-            objv[0] = objPtr;
-            objv[1] = listObj;
-
-            objPtr = Jim_DictMerge(interp, 2, objv);
-            if (objPtr == NULL) {
-
-                Jim_SetResultFormatted(interp, "can't set \"%#s(dev)\": variable isn't array", varName);
-                Jim_FreeNewObj(interp, listObj);
-                return JIM_ERR;
-            }
-
-            Jim_InvalidateStringRep(objPtr);
-
-            Jim_FreeNewObj(interp, listObj);
-            listObj = objPtr;
-        }
-        Jim_SetVariable(interp, varName, listObj);
-    }
-
-
-    Jim_SetResult(interp, listObj);
-
-    return JIM_OK;
-}
-
-static int JimPathLenNoTrailingSlashes(const char *path, int len)
-{
-    int i;
-    for (i = len; i > 1 && path[i - 1] == '/'; i--) {
-
-        if (ISWINDOWS && path[i - 2] == ':') {
-
-            break;
-        }
-    }
-    return i;
-}
-
-static Jim_Obj *JimStripTrailingSlashes(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    int len = Jim_Length(objPtr);
-    const char *path = Jim_String(objPtr);
-    int i = JimPathLenNoTrailingSlashes(path, len);
-    if (i != len) {
-        objPtr = Jim_NewStringObj(interp, path, i);
-    }
-    Jim_IncrRefCount(objPtr);
-    return objPtr;
-}
-
-static int file_cmd_dirname(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *objPtr = JimStripTrailingSlashes(interp, argv[0]);
-    const char *path = Jim_String(objPtr);
-    const char *p = strrchr(path, '/');
-
-    if (!p) {
-        Jim_SetResultString(interp, ".", -1);
-    }
-    else if (p[1] == 0) {
-
-        Jim_SetResult(interp, objPtr);
-    }
-    else if (p == path) {
-        Jim_SetResultString(interp, "/", -1);
-    }
-    else if (ISWINDOWS && p[-1] == ':') {
-
-        Jim_SetResultString(interp, path, p - path + 1);
-    }
-    else {
-
-        int len = JimPathLenNoTrailingSlashes(path, p - path);
-        Jim_SetResultString(interp, path, len);
-    }
-    Jim_DecrRefCount(interp, objPtr);
-    return JIM_OK;
-}
-
-static int file_cmd_split(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
-    const char *path = Jim_String(argv[0]);
-
-    if (*path == '/') {
-        Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, "/", 1));
-    }
-
-    while (1) {
-
-        while (*path == '/') {
-            path++;
-        }
-        if (*path) {
-            const char *pt = strchr(path, '/');
-            if (pt) {
-                Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, path, pt - path));
-                path = pt;
-                continue;
-            }
-            Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, path, -1));
-        }
-        break;
-    }
-    Jim_SetResult(interp, listObj);
-    return JIM_OK;
-}
-
-static int file_cmd_rootname(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    const char *path = Jim_String(argv[0]);
-    const char *lastSlash = strrchr(path, '/');
-    const char *p = strrchr(path, '.');
-
-    if (p == NULL || (lastSlash != NULL && lastSlash > p)) {
-        Jim_SetResult(interp, argv[0]);
-    }
-    else {
-        Jim_SetResultString(interp, path, p - path);
-    }
-    return JIM_OK;
-}
-
-static int file_cmd_extension(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *objPtr = JimStripTrailingSlashes(interp, argv[0]);
-    const char *path = Jim_String(objPtr);
-    const char *lastSlash = strrchr(path, '/');
-    const char *p = strrchr(path, '.');
-
-    if (p == NULL || (lastSlash != NULL && lastSlash >= p)) {
-        p = "";
-    }
-    Jim_SetResultString(interp, p, -1);
-    Jim_DecrRefCount(interp, objPtr);
-    return JIM_OK;
-}
-
-static int file_cmd_tail(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *objPtr = JimStripTrailingSlashes(interp, argv[0]);
-    const char *path = Jim_String(objPtr);
-    const char *lastSlash = strrchr(path, '/');
-
-    if (lastSlash) {
-        Jim_SetResultString(interp, lastSlash + 1, -1);
-    }
-    else {
-        Jim_SetResult(interp, objPtr);
-    }
-    Jim_DecrRefCount(interp, objPtr);
-    return JIM_OK;
-}
-
-#ifndef HAVE_RESTRICT
-#define restrict
-#endif
-
-static char *JimRealPath(const char *restrict path, char *restrict resolved_path, size_t len)
-{
-#if defined(HAVE__FULLPATH)
-    return _fullpath(resolved_path, path, len);
-#elif defined(HAVE_REALPATH)
-    return realpath(path, resolved_path);
-#else
-    return NULL;
-#endif
-}
-
-static int file_cmd_normalize(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    const char *path = Jim_String(argv[0]);
-    char *newname = Jim_Alloc(MAXPATHLEN);
-
-    if (JimRealPath(path, newname, MAXPATHLEN)) {
-        JimFixPath(newname);
-        Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, newname, -1));
-        return JIM_OK;
-    }
-    Jim_Free(newname);
-    Jim_SetResultFormatted(interp, "can't normalize \"%#s\": %s", argv[0], strerror(errno));
-    return JIM_ERR;
-}
-
-static int file_cmd_join(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int i;
-    char *newname = Jim_Alloc(MAXPATHLEN + 1);
-    char *last = newname;
-
-    *newname = 0;
-
-
-    for (i = 0; i < argc; i++) {
-        int len;
-        const char *part = Jim_GetString(argv[i], &len);
-
-        if (*part == '/') {
-
-            last = newname;
-        }
-        else if (ISWINDOWS && strchr(part, ':')) {
-
-            last = newname;
-        }
-        else if (part[0] == '.') {
-            if (part[1] == '/') {
-                part += 2;
-                len -= 2;
-            }
-            else if (part[1] == 0 && last != newname) {
-
-                continue;
-            }
-        }
-
-
-        if (last != newname && last[-1] != '/') {
-            *last++ = '/';
-        }
-
-        if (len) {
-            if (last + len - newname >= MAXPATHLEN) {
-                Jim_Free(newname);
-                Jim_SetResultString(interp, "Path too long", -1);
-                return JIM_ERR;
-            }
-            memcpy(last, part, len);
-            last += len;
-        }
-
-
-        if (last > newname + 1 && last[-1] == '/') {
-
-            if (!ISWINDOWS || !(last > newname + 2 && last[-2] == ':')) {
-                *--last = 0;
-            }
-        }
-    }
-
-    *last = 0;
-
-
-
-    Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, newname, last - newname));
-
-    return JIM_OK;
-}
-
-static int file_access(Jim_Interp *interp, Jim_Obj *filename, int mode)
-{
-    Jim_SetResultBool(interp, access(Jim_String(filename), mode) != -1);
-
-    return JIM_OK;
-}
-
-static int file_cmd_readable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return file_access(interp, argv[0], R_OK);
-}
-
-static int file_cmd_writable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return file_access(interp, argv[0], W_OK);
-}
-
-static int file_cmd_executable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-#ifdef X_OK
-    return file_access(interp, argv[0], X_OK);
-#else
-
-    Jim_SetResultBool(interp, 1);
-    return JIM_OK;
-#endif
-}
-
-static int file_cmd_exists(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return file_access(interp, argv[0], F_OK);
-}
-
-static int file_cmd_delete(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int force = Jim_CompareStringImmediate(interp, argv[0], "-force");
-
-    if (force || Jim_CompareStringImmediate(interp, argv[0], "--")) {
-        argc--;
-        argv++;
-    }
-
-    while (argc--) {
-        const char *path = Jim_String(argv[0]);
-
-        if (unlink(path) == -1 && errno != ENOENT) {
-            if (rmdir(path) == -1) {
-
-                if (!force || Jim_EvalPrefix(interp, "file delete force", 1, argv) != JIM_OK) {
-                    Jim_SetResultFormatted(interp, "couldn't delete file \"%s\": %s", path,
-                        strerror(errno));
-                    return JIM_ERR;
-                }
-            }
-        }
-        argv++;
-    }
-    return JIM_OK;
-}
-
-#ifdef HAVE_MKDIR_ONE_ARG
-#define MKDIR_DEFAULT(PATHNAME) mkdir(PATHNAME)
-#else
-#define MKDIR_DEFAULT(PATHNAME) mkdir(PATHNAME, 0755)
-#endif
-
-static int mkdir_all(char *path)
-{
-    int ok = 1;
-
-
-    goto first;
-
-    while (ok--) {
-
-        {
-            char *slash = strrchr(path, '/');
-
-            if (slash && slash != path) {
-                *slash = 0;
-                if (mkdir_all(path) != 0) {
-                    return -1;
-                }
-                *slash = '/';
-            }
-        }
-      first:
-        if (MKDIR_DEFAULT(path) == 0) {
-            return 0;
-        }
-        if (errno == ENOENT) {
-
-            continue;
-        }
-
-        if (errno == EEXIST) {
-            jim_stat_t sb;
-
-            if (Jim_Stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
-                return 0;
-            }
-
-            errno = EEXIST;
-        }
-
-        break;
-    }
-    return -1;
-}
-
-static int file_cmd_mkdir(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    while (argc--) {
-        char *path = Jim_StrDup(Jim_String(argv[0]));
-        int rc = mkdir_all(path);
-
-        Jim_Free(path);
-        if (rc != 0) {
-            Jim_SetResultFormatted(interp, "can't create directory \"%#s\": %s", argv[0],
-                strerror(errno));
-            return JIM_ERR;
-        }
-        argv++;
-    }
-    return JIM_OK;
-}
-
-static int file_cmd_tempfile(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int fd = Jim_MakeTempFile(interp, (argc >= 1) ? Jim_String(argv[0]) : NULL, 0);
-
-    if (fd < 0) {
-        return JIM_ERR;
-    }
-    close(fd);
-
-    return JIM_OK;
-}
-
-static int file_cmd_rename(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    const char *source;
-    const char *dest;
-    int force = 0;
-
-    if (argc == 3) {
-        if (!Jim_CompareStringImmediate(interp, argv[0], "-force")) {
-            return -1;
-        }
-        force++;
-        argv++;
-        argc--;
-    }
-
-    source = Jim_String(argv[0]);
-    dest = Jim_String(argv[1]);
-
-    if (!force && access(dest, F_OK) == 0) {
-        Jim_SetResultFormatted(interp, "error renaming \"%#s\" to \"%#s\": target exists", argv[0],
-            argv[1]);
-        return JIM_ERR;
-    }
-#if ISWINDOWS
-    if (access(dest, F_OK) == 0) {
-
-        remove(dest);
-    }
-#endif
-    if (rename(source, dest) != 0) {
-        Jim_SetResultFormatted(interp, "error renaming \"%#s\" to \"%#s\": %s", argv[0], argv[1],
-            strerror(errno));
-        return JIM_ERR;
-    }
-
-    return JIM_OK;
-}
-
-#if defined(HAVE_LINK) && defined(HAVE_SYMLINK)
-static int file_cmd_link(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int ret;
-    const char *source;
-    const char *dest;
-    static const char * const options[] = { "-hard", "-symbolic", NULL };
-    enum { OPT_HARD, OPT_SYMBOLIC, };
-    int option = OPT_HARD;
-
-    if (argc == 3) {
-        if (Jim_GetEnum(interp, argv[0], options, &option, NULL, JIM_ENUM_ABBREV | JIM_ERRMSG) != JIM_OK) {
-            return JIM_ERR;
-        }
-        argv++;
-        argc--;
-    }
-
-    dest = Jim_String(argv[0]);
-    source = Jim_String(argv[1]);
-
-    if (option == OPT_HARD) {
-        ret = link(source, dest);
-    }
-    else {
-        ret = symlink(source, dest);
-    }
-
-    if (ret != 0) {
-        Jim_SetResultFormatted(interp, "error linking \"%#s\" to \"%#s\": %s", argv[0], argv[1],
-            strerror(errno));
-        return JIM_ERR;
-    }
-
-    return JIM_OK;
-}
-#endif
-
-static int file_stat(Jim_Interp *interp, Jim_Obj *filename, jim_stat_t *sb)
-{
-    const char *path = Jim_String(filename);
-
-    if (Jim_Stat(path, sb) == -1) {
-        Jim_SetResultFormatted(interp, "could not read \"%#s\": %s", filename, strerror(errno));
-        return JIM_ERR;
-    }
-    return JIM_OK;
-}
-
-#ifdef Jim_LinkStat
-static int file_lstat(Jim_Interp *interp, Jim_Obj *filename, jim_stat_t *sb)
-{
-    const char *path = Jim_String(filename);
-
-    if (Jim_LinkStat(path, sb) == -1) {
-        Jim_SetResultFormatted(interp, "could not read \"%#s\": %s", filename, strerror(errno));
-        return JIM_ERR;
-    }
-    return JIM_OK;
-}
-#else
-#define file_lstat file_stat
-#endif
-
-static int file_cmd_atime(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    jim_stat_t sb;
-
-    if (file_stat(interp, argv[0], &sb) != JIM_OK) {
-        return JIM_ERR;
-    }
-    Jim_SetResultInt(interp, sb.st_atime);
-    return JIM_OK;
-}
-
-static int JimSetFileTimes(Jim_Interp *interp, const char *filename, jim_wide us)
-{
-#ifdef HAVE_UTIMES
-    struct timeval times[2];
-
-    times[1].tv_sec = times[0].tv_sec = us / 1000000;
-    times[1].tv_usec = times[0].tv_usec = us % 1000000;
-
-    if (utimes(filename, times) != 0) {
-        Jim_SetResultFormatted(interp, "can't set time on \"%s\": %s", filename, strerror(errno));
-        return JIM_ERR;
-    }
-    return JIM_OK;
-#else
-    Jim_SetResultString(interp, "Not implemented", -1);
-    return JIM_ERR;
-#endif
-}
-
-static int file_cmd_mtime(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    jim_stat_t sb;
-
-    if (argc == 2) {
-        jim_wide secs;
-        if (Jim_GetWide(interp, argv[1], &secs) != JIM_OK) {
-            return JIM_ERR;
-        }
-        return JimSetFileTimes(interp, Jim_String(argv[0]), secs * 1000000);
-    }
-    if (file_stat(interp, argv[0], &sb) != JIM_OK) {
-        return JIM_ERR;
-    }
-    Jim_SetResultInt(interp, sb.st_mtime);
-    return JIM_OK;
-}
-
-#ifdef STAT_MTIME_US
-static int file_cmd_mtimeus(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    jim_stat_t sb;
-
-    if (argc == 2) {
-        jim_wide us;
-        if (Jim_GetWide(interp, argv[1], &us) != JIM_OK) {
-            return JIM_ERR;
-        }
-        return JimSetFileTimes(interp, Jim_String(argv[0]), us);
-    }
-    if (file_stat(interp, argv[0], &sb) != JIM_OK) {
-        return JIM_ERR;
-    }
-    Jim_SetResultInt(interp, STAT_MTIME_US(sb));
-    return JIM_OK;
-}
-#endif
-
-static int file_cmd_copy(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return Jim_EvalPrefix(interp, "file copy", argc, argv);
-}
-
-static int file_cmd_size(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    jim_stat_t sb;
-
-    if (file_stat(interp, argv[0], &sb) != JIM_OK) {
-        return JIM_ERR;
-    }
-    Jim_SetResultInt(interp, sb.st_size);
-    return JIM_OK;
-}
-
-static int file_cmd_isdirectory(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    jim_stat_t sb;
-    int ret = 0;
-
-    if (file_stat(interp, argv[0], &sb) == JIM_OK) {
-        ret = S_ISDIR(sb.st_mode);
-    }
-    Jim_SetResultInt(interp, ret);
-    return JIM_OK;
-}
-
-static int file_cmd_isfile(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    jim_stat_t sb;
-    int ret = 0;
-
-    if (file_stat(interp, argv[0], &sb) == JIM_OK) {
-        ret = S_ISREG(sb.st_mode);
-    }
-    Jim_SetResultInt(interp, ret);
-    return JIM_OK;
-}
-
-#ifdef HAVE_GETEUID
-static int file_cmd_owned(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    jim_stat_t sb;
-    int ret = 0;
-
-    if (file_stat(interp, argv[0], &sb) == JIM_OK) {
-        ret = (geteuid() == sb.st_uid);
-    }
-    Jim_SetResultInt(interp, ret);
-    return JIM_OK;
-}
-#endif
-
-#if defined(HAVE_READLINK)
-static int file_cmd_readlink(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    const char *path = Jim_String(argv[0]);
-    char *linkValue = Jim_Alloc(MAXPATHLEN + 1);
-
-    int linkLength = readlink(path, linkValue, MAXPATHLEN);
-
-    if (linkLength == -1) {
-        Jim_Free(linkValue);
-        Jim_SetResultFormatted(interp, "could not read link \"%#s\": %s", argv[0], strerror(errno));
-        return JIM_ERR;
-    }
-    linkValue[linkLength] = 0;
-    Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, linkValue, linkLength));
-    return JIM_OK;
-}
-#endif
-
-static int file_cmd_type(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    jim_stat_t sb;
-
-    if (file_lstat(interp, argv[0], &sb) != JIM_OK) {
-        return JIM_ERR;
-    }
-    Jim_SetResultString(interp, JimGetFileType((int)sb.st_mode), -1);
-    return JIM_OK;
-}
-
-#ifdef Jim_LinkStat
-static int file_cmd_lstat(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    jim_stat_t sb;
-
-    if (file_lstat(interp, argv[0], &sb) != JIM_OK) {
-        return JIM_ERR;
-    }
-    return Jim_FileStoreStatData(interp, argc == 2 ? argv[1] : NULL, &sb);
-}
-#else
-#define file_cmd_lstat file_cmd_stat
-#endif
-
-static int file_cmd_stat(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    jim_stat_t sb;
-
-    if (file_stat(interp, argv[0], &sb) != JIM_OK) {
-        return JIM_ERR;
-    }
-    return Jim_FileStoreStatData(interp, argc == 2 ? argv[1] : NULL, &sb);
-}
-
-static const jim_subcmd_type file_command_table[] = {
-    {   "atime",
-        "name",
-        file_cmd_atime,
-        1,
-        1,
-
-    },
-    {   "mtime",
-        "name ?time?",
-        file_cmd_mtime,
-        1,
-        2,
-
-    },
-#ifdef STAT_MTIME_US
-    {   "mtimeus",
-        "name ?time?",
-        file_cmd_mtimeus,
-        1,
-        2,
-
-    },
-#endif
-    {   "copy",
-        "?-force? source dest",
-        file_cmd_copy,
-        2,
-        3,
-
-    },
-    {   "dirname",
-        "name",
-        file_cmd_dirname,
-        1,
-        1,
-
-    },
-    {   "rootname",
-        "name",
-        file_cmd_rootname,
-        1,
-        1,
-
-    },
-    {   "extension",
-        "name",
-        file_cmd_extension,
-        1,
-        1,
-
-    },
-    {   "tail",
-        "name",
-        file_cmd_tail,
-        1,
-        1,
-
-    },
-    {   "split",
-        "name",
-        file_cmd_split,
-        1,
-        1,
-
-    },
-    {   "normalize",
-        "name",
-        file_cmd_normalize,
-        1,
-        1,
-
-    },
-    {   "join",
-        "name ?name ...?",
-        file_cmd_join,
-        1,
-        -1,
-
-    },
-    {   "readable",
-        "name",
-        file_cmd_readable,
-        1,
-        1,
-
-    },
-    {   "writable",
-        "name",
-        file_cmd_writable,
-        1,
-        1,
-
-    },
-    {   "executable",
-        "name",
-        file_cmd_executable,
-        1,
-        1,
-
-    },
-    {   "exists",
-        "name",
-        file_cmd_exists,
-        1,
-        1,
-
-    },
-    {   "delete",
-        "?-force|--? name ...",
-        file_cmd_delete,
-        1,
-        -1,
-
-    },
-    {   "mkdir",
-        "dir ...",
-        file_cmd_mkdir,
-        1,
-        -1,
-
-    },
-    {   "tempfile",
-        "?template?",
-        file_cmd_tempfile,
-        0,
-        1,
-
-    },
-    {   "rename",
-        "?-force? source dest",
-        file_cmd_rename,
-        2,
-        3,
-
-    },
-#if defined(HAVE_LINK) && defined(HAVE_SYMLINK)
-    {   "link",
-        "?-symbolic|-hard? newname target",
-        file_cmd_link,
-        2,
-        3,
-
-    },
-#endif
-#if defined(HAVE_READLINK)
-    {   "readlink",
-        "name",
-        file_cmd_readlink,
-        1,
-        1,
-
-    },
-#endif
-    {   "size",
-        "name",
-        file_cmd_size,
-        1,
-        1,
-
-    },
-    {   "stat",
-        "name ?var?",
-        file_cmd_stat,
-        1,
-        2,
-
-    },
-    {   "lstat",
-        "name ?var?",
-        file_cmd_lstat,
-        1,
-        2,
-
-    },
-    {   "type",
-        "name",
-        file_cmd_type,
-        1,
-        1,
-
-    },
-#ifdef HAVE_GETEUID
-    {   "owned",
-        "name",
-        file_cmd_owned,
-        1,
-        1,
-
-    },
-#endif
-    {   "isdirectory",
-        "name",
-        file_cmd_isdirectory,
-        1,
-        1,
-
-    },
-    {   "isfile",
-        "name",
-        file_cmd_isfile,
-        1,
-        1,
-
-    },
-    {
-        NULL
-    }
-};
-
-static int Jim_CdCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    const char *path;
-
-    if (argc != 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "dirname");
-        return JIM_ERR;
-    }
-
-    path = Jim_String(argv[1]);
-
-    if (chdir(path) != 0) {
-        Jim_SetResultFormatted(interp, "couldn't change working directory to \"%s\": %s", path,
-            strerror(errno));
-        return JIM_ERR;
-    }
-    return JIM_OK;
-}
-
-static int Jim_PwdCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    char *cwd = Jim_Alloc(MAXPATHLEN);
-
-    if (getcwd(cwd, MAXPATHLEN) == NULL) {
-        Jim_SetResultString(interp, "Failed to get pwd", -1);
-        Jim_Free(cwd);
-        return JIM_ERR;
-    }
-    JimFixPath(cwd);
-    Jim_SetResultString(interp, cwd, -1);
-
-    Jim_Free(cwd);
-    return JIM_OK;
-}
-
-int Jim_fileInit(Jim_Interp *interp)
-{
-    Jim_PackageProvideCheck(interp, "file");
-    Jim_CreateCommand(interp, "file", Jim_SubCmdProc, (void *)file_command_table, NULL);
-    Jim_CreateCommand(interp, "pwd", Jim_PwdCmd, NULL, NULL);
-    Jim_CreateCommand(interp, "cd", Jim_CdCmd, NULL, NULL);
-    return JIM_OK;
-}
-
-#include <string.h>
-#include <ctype.h>
-
-
-#if (!(defined(HAVE_VFORK) || defined(HAVE_FORK)) || !defined(HAVE_WAITPID)) && !defined(__MINGW32__)
-static int Jim_ExecCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *cmdlineObj = Jim_NewEmptyStringObj(interp);
-    int i, j;
-    int rc;
-
-
-    for (i = 1; i < argc; i++) {
-        int len;
-        const char *arg = Jim_GetString(argv[i], &len);
-
-        if (i > 1) {
-            Jim_AppendString(interp, cmdlineObj, " ", 1);
-        }
-        if (strpbrk(arg, "\\\" ") == NULL) {
-
-            Jim_AppendString(interp, cmdlineObj, arg, len);
-            continue;
-        }
-
-        Jim_AppendString(interp, cmdlineObj, "\"", 1);
-        for (j = 0; j < len; j++) {
-            if (arg[j] == '\\' || arg[j] == '"') {
-                Jim_AppendString(interp, cmdlineObj, "\\", 1);
-            }
-            Jim_AppendString(interp, cmdlineObj, &arg[j], 1);
-        }
-        Jim_AppendString(interp, cmdlineObj, "\"", 1);
-    }
-    rc = system(Jim_String(cmdlineObj));
-
-    Jim_FreeNewObj(interp, cmdlineObj);
-
-    if (rc) {
-        Jim_Obj *errorCode = Jim_NewListObj(interp, NULL, 0);
-        Jim_ListAppendElement(interp, errorCode, Jim_NewStringObj(interp, "CHILDSTATUS", -1));
-        Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, 0));
-        Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, rc));
-        Jim_SetGlobalVariableStr(interp, "errorCode", errorCode);
-        return JIM_ERR;
-    }
-
-    return JIM_OK;
-}
-
-int Jim_execInit(Jim_Interp *interp)
-{
-    Jim_PackageProvideCheck(interp, "exec");
-    Jim_CreateCommand(interp, "exec", Jim_ExecCmd, NULL, NULL);
-    return JIM_OK;
-}
-#else
-
-
-#include <errno.h>
-#include <signal.h>
-#include <sys/stat.h>
-
-struct WaitInfoTable;
-
-static char **JimOriginalEnviron(void);
-static char **JimSaveEnv(char **env);
-static void JimRestoreEnv(char **env);
-static int JimCreatePipeline(Jim_Interp *interp, int argc, Jim_Obj *const *argv,
-    phandle_t **pidArrayPtr, int *inPipePtr, int *outPipePtr, int *errFilePtr);
-static void JimDetachPids(struct WaitInfoTable *table, int numPids, const phandle_t *pidPtr);
-static int JimCleanupChildren(Jim_Interp *interp, int numPids, phandle_t *pidPtr, Jim_Obj *errStrObj);
-static int Jim_WaitCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
-
-#if defined(__MINGW32__)
-static phandle_t JimStartWinProcess(Jim_Interp *interp, char **argv, char **env, int inputId, int outputId, int errorId);
-#endif
-
-static void Jim_RemoveTrailingNewline(Jim_Obj *objPtr)
-{
-    int len;
-    const char *s = Jim_GetString(objPtr, &len);
-
-    if (len > 0 && s[len - 1] == '\n') {
-        objPtr->length--;
-        objPtr->bytes[objPtr->length] = '\0';
-    }
-}
-
-static int JimAppendStreamToString(Jim_Interp *interp, int fd, Jim_Obj *strObj)
-{
-    char buf[256];
-    int ret = 0;
-
-    while (1) {
-        int retval = read(fd, buf, sizeof(buf));
-        if (retval > 0) {
-            ret = 1;
-            Jim_AppendString(interp, strObj, buf, retval);
-        }
-        if (retval <= 0) {
-            break;
-        }
-    }
-    close(fd);
-    return ret;
-}
-
-static char **JimBuildEnv(Jim_Interp *interp)
-{
-    int i;
-    int size;
-    int num;
-    int n;
-    char **envptr;
-    char *envdata;
-
-    Jim_Obj *objPtr = Jim_GetGlobalVariableStr(interp, "env", JIM_NONE);
-
-    if (!objPtr) {
-        return JimOriginalEnviron();
-    }
-
-
-
-    num = Jim_ListLength(interp, objPtr);
-    if (num % 2) {
-
-        num--;
-    }
-    size = Jim_Length(objPtr) + 2;
-
-    envptr = Jim_Alloc(sizeof(*envptr) * (num / 2 + 1) + size);
-    envdata = (char *)&envptr[num / 2 + 1];
-
-    n = 0;
-    for (i = 0; i < num; i += 2) {
-        const char *s1, *s2;
-        Jim_Obj *elemObj;
-
-        Jim_ListIndex(interp, objPtr, i, &elemObj, JIM_NONE);
-        s1 = Jim_String(elemObj);
-        Jim_ListIndex(interp, objPtr, i + 1, &elemObj, JIM_NONE);
-        s2 = Jim_String(elemObj);
-
-        envptr[n] = envdata;
-        envdata += sprintf(envdata, "%s=%s", s1, s2);
-        envdata++;
-        n++;
-    }
-    envptr[n] = NULL;
-    *envdata = 0;
-
-    return envptr;
-}
-
-static void JimFreeEnv(char **env, char **original_environ)
-{
-    if (env != original_environ) {
-        Jim_Free(env);
-    }
-}
-
-static Jim_Obj *JimMakeErrorCode(Jim_Interp *interp, long pid, int waitStatus, Jim_Obj *errStrObj)
-{
-    Jim_Obj *errorCode = Jim_NewListObj(interp, NULL, 0);
-
-    if (pid <= 0) {
-        Jim_ListAppendElement(interp, errorCode, Jim_NewStringObj(interp, "NONE", -1));
-        Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, pid));
-        Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, -1));
-    }
-    else if (WIFEXITED(waitStatus)) {
-        Jim_ListAppendElement(interp, errorCode, Jim_NewStringObj(interp, "CHILDSTATUS", -1));
-        Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, pid));
-        Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, WEXITSTATUS(waitStatus)));
-    }
-    else {
-        const char *type;
-        const char *action;
-        const char *signame;
-
-        if (WIFSIGNALED(waitStatus)) {
-            type = "CHILDKILLED";
-            action = "killed";
-            signame = Jim_SignalId(WTERMSIG(waitStatus));
-        }
-        else {
-            type = "CHILDSUSP";
-            action = "suspended";
-            signame = "none";
-        }
-
-        Jim_ListAppendElement(interp, errorCode, Jim_NewStringObj(interp, type, -1));
-
-        if (errStrObj) {
-            Jim_AppendStrings(interp, errStrObj, "child ", action, " by signal ", Jim_SignalId(WTERMSIG(waitStatus)), "\n", NULL);
-        }
-
-        Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, pid));
-        Jim_ListAppendElement(interp, errorCode, Jim_NewStringObj(interp, signame, -1));
-    }
-    return errorCode;
-}
-
-static int JimCheckWaitStatus(Jim_Interp *interp, long pid, int waitStatus, Jim_Obj *errStrObj)
-{
-    if (WIFEXITED(waitStatus) && WEXITSTATUS(waitStatus) == 0) {
-        return JIM_OK;
-    }
-    Jim_SetGlobalVariableStr(interp, "errorCode", JimMakeErrorCode(interp, pid, waitStatus, errStrObj));
-
-    return JIM_ERR;
-}
-
-
-struct WaitInfo
-{
-    phandle_t phandle;
-    int status;
-    int flags;
-};
-
-
-struct WaitInfoTable {
-    struct WaitInfo *info;
-    int size;
-    int used;
-    int refcount;
-};
-
-
-#define WI_DETACHED 2
-
-#define WAIT_TABLE_GROW_BY 4
-
-static void JimFreeWaitInfoTable(struct Jim_Interp *interp, void *privData)
-{
-    struct WaitInfoTable *table = privData;
-
-    if (--table->refcount == 0) {
-        Jim_Free(table->info);
-        Jim_Free(table);
-    }
-}
-
-static struct WaitInfoTable *JimAllocWaitInfoTable(void)
-{
-    struct WaitInfoTable *table = Jim_Alloc(sizeof(*table));
-    table->info = NULL;
-    table->size = table->used = 0;
-    table->refcount = 1;
-
-    return table;
-}
-
-static int JimWaitRemove(struct WaitInfoTable *table, phandle_t phandle)
-{
-    int i;
-
-
-    for (i = 0; i < table->used; i++) {
-        if (phandle == table->info[i].phandle) {
-            if (i != table->used - 1) {
-                table->info[i] = table->info[table->used - 1];
-            }
-            table->used--;
-            return 0;
-        }
-    }
-    return -1;
-}
-
-static int Jim_ExecCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int outputId;
-    int errorId;
-    phandle_t *pidPtr;
-    int numPids, result;
-    int child_siginfo = 1;
-    Jim_Obj *childErrObj;
-    Jim_Obj *errStrObj;
-    struct WaitInfoTable *table = Jim_CmdPrivData(interp);
-
-    if (argc > 1 && Jim_CompareStringImmediate(interp, argv[argc - 1], "&")) {
-        Jim_Obj *listObj;
-        int i;
-
-        argc--;
-        numPids = JimCreatePipeline(interp, argc - 1, argv + 1, &pidPtr, NULL, NULL, NULL);
-        if (numPids < 0) {
-            return JIM_ERR;
-        }
-
-        listObj = Jim_NewListObj(interp, NULL, 0);
-        for (i = 0; i < numPids; i++) {
-            Jim_ListAppendElement(interp, listObj, Jim_NewIntObj(interp, JimProcessPid(pidPtr[i])));
-        }
-        Jim_SetResult(interp, listObj);
-        JimDetachPids(table, numPids, pidPtr);
-        Jim_Free(pidPtr);
-        return JIM_OK;
-    }
-
-    numPids =
-        JimCreatePipeline(interp, argc - 1, argv + 1, &pidPtr, NULL, &outputId, &errorId);
-
-    if (numPids < 0) {
-        return JIM_ERR;
-    }
-
-    result = JIM_OK;
-
-    errStrObj = Jim_NewStringObj(interp, "", 0);
-
-
-    if (outputId != -1) {
-        if (JimAppendStreamToString(interp, outputId, errStrObj) < 0) {
-            result = JIM_ERR;
-            Jim_SetResultErrno(interp, "error reading from output pipe");
-        }
-    }
-
-
-    childErrObj = Jim_NewStringObj(interp, "", 0);
-    Jim_IncrRefCount(childErrObj);
-
-    if (JimCleanupChildren(interp, numPids, pidPtr, childErrObj) != JIM_OK) {
-        result = JIM_ERR;
-    }
-
-    if (errorId != -1) {
-        int ret;
-        Jim_Lseek(errorId, 0, SEEK_SET);
-        ret = JimAppendStreamToString(interp, errorId, errStrObj);
-        if (ret < 0) {
-            Jim_SetResultErrno(interp, "error reading from error pipe");
-            result = JIM_ERR;
-        }
-        else if (ret > 0) {
-
-            child_siginfo = 0;
-        }
-    }
-
-    if (child_siginfo) {
-
-        Jim_AppendObj(interp, errStrObj, childErrObj);
-    }
-    Jim_DecrRefCount(interp, childErrObj);
-
-
-    Jim_RemoveTrailingNewline(errStrObj);
-
-
-    Jim_SetResult(interp, errStrObj);
-
-    return result;
-}
-
-static long JimWaitForProcess(struct WaitInfoTable *table, phandle_t phandle, int *statusPtr)
-{
-    if (JimWaitRemove(table, phandle) == 0) {
-
-         return waitpid(phandle, statusPtr, 0);
-    }
-
-
-    return -1;
-}
-
-static void JimDetachPids(struct WaitInfoTable *table, int numPids, const phandle_t *pidPtr)
-{
-    int j;
-
-    for (j = 0; j < numPids; j++) {
-
-        int i;
-        for (i = 0; i < table->used; i++) {
-            if (pidPtr[j] == table->info[i].phandle) {
-                table->info[i].flags |= WI_DETACHED;
-                break;
-            }
-        }
-    }
-}
-
-static int JimGetChannelFd(Jim_Interp *interp, const char *name)
-{
-    Jim_Obj *objv[2];
-
-    objv[0] = Jim_NewStringObj(interp, name, -1);
-    objv[1] = Jim_NewStringObj(interp, "getfd", -1);
-
-    if (Jim_EvalObjVector(interp, 2, objv) == JIM_OK) {
-        jim_wide fd;
-        if (Jim_GetWide(interp, Jim_GetResult(interp), &fd) == JIM_OK) {
-            return fd;
-        }
-    }
-    return -1;
-}
-
-static void JimReapDetachedPids(struct WaitInfoTable *table)
-{
-    struct WaitInfo *waitPtr;
-    int count;
-    int dest;
-
-    if (!table) {
-        return;
-    }
-
-    waitPtr = table->info;
-    dest = 0;
-    for (count = table->used; count > 0; waitPtr++, count--) {
-        if (waitPtr->flags & WI_DETACHED) {
-            int status;
-            long pid = waitpid(waitPtr->phandle, &status, WNOHANG);
-            if (pid > 0) {
-
-                table->used--;
-                continue;
-            }
-        }
-        if (waitPtr != &table->info[dest]) {
-            table->info[dest] = *waitPtr;
-        }
-        dest++;
-    }
-}
-
-static int Jim_WaitCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    struct WaitInfoTable *table = Jim_CmdPrivData(interp);
-    int nohang = 0;
-    long pid;
-    phandle_t phandle;
-    int status;
-    Jim_Obj *errCodeObj;
-
-
-    if (argc == 1) {
-        JimReapDetachedPids(table);
-        return JIM_OK;
-    }
-
-    if (argc > 1 && Jim_CompareStringImmediate(interp, argv[1], "-nohang")) {
-        nohang = 1;
-    }
-    if (argc != nohang + 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "?-nohang? ?pid?");
-        return JIM_ERR;
-    }
-    if (Jim_GetLong(interp, argv[nohang + 1], &pid) != JIM_OK) {
-        return JIM_ERR;
-    }
-
-
-    phandle = JimWaitPid(pid, &status, nohang ? WNOHANG : 0);
-    if (phandle == JIM_BAD_PHANDLE) {
-        pid = -1;
-    }
-#ifndef __MINGW32__
-    else if (pid < 0) {
-        pid = phandle;
-    }
-#endif
-
-    errCodeObj = JimMakeErrorCode(interp, pid, status, NULL);
-
-    if (phandle != JIM_BAD_PHANDLE && (WIFEXITED(status) || WIFSIGNALED(status))) {
-
-        JimWaitRemove(table, phandle);
-    }
-    Jim_SetResult(interp, errCodeObj);
-    return JIM_OK;
-}
-
-static int Jim_PidCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    if (argc != 1) {
-        Jim_WrongNumArgs(interp, 1, argv, "");
-        return JIM_ERR;
-    }
-
-    Jim_SetResultInt(interp, (jim_wide)getpid());
-    return JIM_OK;
-}
-
-static int
-JimCreatePipeline(Jim_Interp *interp, int argc, Jim_Obj *const *argv, phandle_t **pidArrayPtr,
-    int *inPipePtr, int *outPipePtr, int *errFilePtr)
-{
-    phandle_t *pidPtr = NULL;         /* Points to alloc-ed array holding all
-                                 * the pids of child processes. */
-    int numPids = 0;            /* Actual number of processes that exist
-                                 * at *pidPtr right now. */
-    int cmdCount;               /* Count of number of distinct commands
-                                 * found in argc/argv. */
-    const char *input = NULL;   /* Describes input for pipeline, depending
-                                 * on "inputFile".  NULL means take input
-                                 * from stdin/pipe. */
-    int input_len = 0;
-
-#define FILE_NAME   0
-#define FILE_APPEND 1
-#define FILE_HANDLE 2
-#define FILE_TEXT   3
-
-    int inputFile = FILE_NAME;  /* 1 means input is name of input file.
-                                 * 2 means input is filehandle name.
-                                 * 0 means input holds actual
-                                 * text to be input to command. */
-
-    int outputFile = FILE_NAME; /* 0 means output is the name of output file.
-                                 * 1 means output is the name of output file, and append.
-                                 * 2 means output is filehandle name.
-                                 * All this is ignored if output is NULL
-                                 */
-    int errorFile = FILE_NAME;  /* 0 means error is the name of error file.
-                                 * 1 means error is the name of error file, and append.
-                                 * 2 means error is filehandle name.
-                                 * All this is ignored if error is NULL
-                                 */
-    const char *output = NULL;  /* Holds name of output file to pipe to,
-                                 * or NULL if output goes to stdout/pipe. */
-    const char *error = NULL;   /* Holds name of stderr file to pipe to,
-                                 * or NULL if stderr goes to stderr/pipe. */
-    int inputId = -1;
-    int outputId = -1;
-    int errorId = -1;
-    int lastOutputId = -1;
-    int pipeIds[2];
-    int firstArg, lastArg;      /* Indexes of first and last arguments in
-                                 * current command. */
-    int lastBar;
-    int i;
-    phandle_t phandle;
-    char **save_environ;
-#if defined(HAVE_EXECVPE) && !defined(__MINGW32__)
-    char **child_environ;
-#endif
-    struct WaitInfoTable *table = Jim_CmdPrivData(interp);
-
-
-    char **arg_array = Jim_Alloc(sizeof(*arg_array) * (argc + 1));
-    int arg_count = 0;
-
-    if (inPipePtr != NULL) {
-        *inPipePtr = -1;
-    }
-    if (outPipePtr != NULL) {
-        *outPipePtr = -1;
-    }
-    if (errFilePtr != NULL) {
-        *errFilePtr = -1;
-    }
-    pipeIds[0] = pipeIds[1] = -1;
-
-    cmdCount = 1;
-    lastBar = -1;
-    for (i = 0; i < argc; i++) {
-        const char *arg = Jim_String(argv[i]);
-
-        if (arg[0] == '<') {
-            inputFile = FILE_NAME;
-            input = arg + 1;
-            if (*input == '<') {
-                inputFile = FILE_TEXT;
-                input_len = Jim_Length(argv[i]) - 2;
-                input++;
-            }
-            else if (*input == '@') {
-                inputFile = FILE_HANDLE;
-                input++;
-            }
-
-            if (!*input && ++i < argc) {
-                input = Jim_GetString(argv[i], &input_len);
-            }
-        }
-        else if (arg[0] == '>') {
-            int dup_error = 0;
-
-            outputFile = FILE_NAME;
-
-            output = arg + 1;
-            if (*output == '>') {
-                outputFile = FILE_APPEND;
-                output++;
-            }
-            if (*output == '&') {
-
-                output++;
-                dup_error = 1;
-            }
-            if (*output == '@') {
-                outputFile = FILE_HANDLE;
-                output++;
-            }
-            if (!*output && ++i < argc) {
-                output = Jim_String(argv[i]);
-            }
-            if (dup_error) {
-                errorFile = outputFile;
-                error = output;
-            }
-        }
-        else if (arg[0] == '2' && arg[1] == '>') {
-            error = arg + 2;
-            errorFile = FILE_NAME;
-
-            if (*error == '@') {
-                errorFile = FILE_HANDLE;
-                error++;
-            }
-            else if (*error == '>') {
-                errorFile = FILE_APPEND;
-                error++;
-            }
-            if (!*error && ++i < argc) {
-                error = Jim_String(argv[i]);
-            }
-        }
-        else {
-            if (strcmp(arg, "|") == 0 || strcmp(arg, "|&") == 0) {
-                if (i == lastBar + 1 || i == argc - 1) {
-                    Jim_SetResultString(interp, "illegal use of | or |& in command", -1);
-                    goto badargs;
-                }
-                lastBar = i;
-                cmdCount++;
-            }
-
-            arg_array[arg_count++] = (char *)arg;
-            continue;
-        }
-
-        if (i >= argc) {
-            Jim_SetResultFormatted(interp, "can't specify \"%s\" as last word in command", arg);
-            goto badargs;
-        }
-    }
-
-    if (arg_count == 0) {
-        Jim_SetResultString(interp, "didn't specify command to execute", -1);
-badargs:
-        Jim_Free(arg_array);
-        return -1;
-    }
-
-
-    save_environ = JimSaveEnv(JimBuildEnv(interp));
-
-    if (input != NULL) {
-        if (inputFile == FILE_TEXT) {
-            inputId = Jim_MakeTempFile(interp, NULL, 1);
-            if (inputId == -1) {
-                goto error;
-            }
-            if (write(inputId, input, input_len) != input_len) {
-                Jim_SetResultErrno(interp, "couldn't write temp file");
-                close(inputId);
-                goto error;
-            }
-            Jim_Lseek(inputId, 0L, SEEK_SET);
-        }
-        else if (inputFile == FILE_HANDLE) {
-            int fd = JimGetChannelFd(interp, input);
-
-            if (fd < 0) {
-                goto error;
-            }
-            inputId = dup(fd);
-        }
-        else {
-            inputId = Jim_OpenForRead(input);
-            if (inputId == -1) {
-                Jim_SetResultFormatted(interp, "couldn't read file \"%s\": %s", input, strerror(Jim_Errno()));
-                goto error;
-            }
-        }
-    }
-    else if (inPipePtr != NULL) {
-        if (pipe(pipeIds) != 0) {
-            Jim_SetResultErrno(interp, "couldn't create input pipe for command");
-            goto error;
-        }
-        inputId = pipeIds[0];
-        *inPipePtr = pipeIds[1];
-        pipeIds[0] = pipeIds[1] = -1;
-    }
-
-    if (output != NULL) {
-        if (outputFile == FILE_HANDLE) {
-            int fd = JimGetChannelFd(interp, output);
-            if (fd < 0) {
-                goto error;
-            }
-            lastOutputId = dup(fd);
-        }
-        else {
-            lastOutputId = Jim_OpenForWrite(output, outputFile == FILE_APPEND);
-            if (lastOutputId == -1) {
-                Jim_SetResultFormatted(interp, "couldn't write file \"%s\": %s", output, strerror(Jim_Errno()));
-                goto error;
-            }
-        }
-    }
-    else if (outPipePtr != NULL) {
-        if (pipe(pipeIds) != 0) {
-            Jim_SetResultErrno(interp, "couldn't create output pipe");
-            goto error;
-        }
-        lastOutputId = pipeIds[1];
-        *outPipePtr = pipeIds[0];
-        pipeIds[0] = pipeIds[1] = -1;
-    }
-
-    if (error != NULL) {
-        if (errorFile == FILE_HANDLE) {
-            if (strcmp(error, "1") == 0) {
-
-                if (lastOutputId != -1) {
-                    errorId = dup(lastOutputId);
-                }
-                else {
-
-                    error = "stdout";
-                }
-            }
-            if (errorId == -1) {
-                int fd = JimGetChannelFd(interp, error);
-                if (fd < 0) {
-                    goto error;
-                }
-                errorId = dup(fd);
-            }
-        }
-        else {
-            errorId = Jim_OpenForWrite(error, errorFile == FILE_APPEND);
-            if (errorId == -1) {
-                Jim_SetResultFormatted(interp, "couldn't write file \"%s\": %s", error, strerror(Jim_Errno()));
-                goto error;
-            }
-        }
-    }
-    else if (errFilePtr != NULL) {
-        errorId = Jim_MakeTempFile(interp, NULL, 1);
-        if (errorId == -1) {
-            goto error;
-        }
-        *errFilePtr = dup(errorId);
-    }
-
-
-    pidPtr = Jim_Alloc(cmdCount * sizeof(*pidPtr));
-    for (firstArg = 0; firstArg < arg_count; numPids++, firstArg = lastArg + 1) {
-        int pipe_dup_err = 0;
-        int origErrorId = errorId;
-
-        for (lastArg = firstArg; lastArg < arg_count; lastArg++) {
-            if (strcmp(arg_array[lastArg], "|") == 0) {
-                break;
-            }
-            if (strcmp(arg_array[lastArg], "|&") == 0) {
-                pipe_dup_err = 1;
-                break;
-            }
-        }
-
-        if (lastArg == firstArg) {
-            Jim_SetResultString(interp, "missing command to exec", -1);
-            goto error;
-        }
-
-
-        arg_array[lastArg] = NULL;
-        if (lastArg == arg_count) {
-            outputId = lastOutputId;
-            lastOutputId = -1;
-        }
-        else {
-            if (pipe(pipeIds) != 0) {
-                Jim_SetResultErrno(interp, "couldn't create pipe");
-                goto error;
-            }
-            outputId = pipeIds[1];
-        }
-
-
-        if (pipe_dup_err) {
-            errorId = outputId;
-        }
-
-
-
-#ifdef __MINGW32__
-        phandle = JimStartWinProcess(interp, &arg_array[firstArg], save_environ, inputId, outputId, errorId);
-        if (phandle == JIM_BAD_PHANDLE) {
-            Jim_SetResultFormatted(interp, "couldn't exec \"%s\"", arg_array[firstArg]);
-            goto error;
-        }
-#else
-        i = strlen(arg_array[firstArg]);
-
-#ifdef HAVE_EXECVPE
-        child_environ = Jim_GetEnviron();
-#endif
-#ifdef HAVE_VFORK
-        phandle = vfork();
-#else
-        phandle = fork();
-#endif
-        if (phandle < 0) {
-            Jim_SetResultErrno(interp, "couldn't fork child process");
-            goto error;
-        }
-        if (phandle == 0) {
-
-
-            if (inputId != -1 && inputId != fileno(stdin)) {
-                dup2(inputId, fileno(stdin));
-                close(inputId);
-            }
-            if (outputId != -1 && outputId != fileno(stdout)) {
-                dup2(outputId, fileno(stdout));
-                if (outputId != errorId) {
-                    close(outputId);
-                }
-            }
-            if (errorId != -1 && errorId != fileno(stderr)) {
-                dup2(errorId, fileno(stderr));
-                close(errorId);
-            }
-
-            if (outPipePtr && *outPipePtr != -1) {
-                close(*outPipePtr);
-            }
-            if (errFilePtr && *errFilePtr != -1) {
-                close(*errFilePtr);
-            }
-            if (pipeIds[0] != -1) {
-                close(pipeIds[0]);
-            }
-            if (lastOutputId != -1) {
-                close(lastOutputId);
-            }
-
-            execvpe(arg_array[firstArg], &arg_array[firstArg], child_environ);
-
-            if (write(fileno(stderr), "couldn't exec \"", 15) &&
-                write(fileno(stderr), arg_array[firstArg], i) &&
-                write(fileno(stderr), "\"\n", 2)) {
-
-            }
-#ifdef JIM_MAINTAINER
-            {
-
-                static char *const false_argv[2] = {"false", NULL};
-                execvp(false_argv[0],false_argv);
-            }
-#endif
-            _exit(127);
-        }
-#endif
-
-
-
-        if (table->used == table->size) {
-            table->size += WAIT_TABLE_GROW_BY;
-            table->info = Jim_Realloc(table->info, table->size * sizeof(*table->info));
-        }
-
-        table->info[table->used].phandle = phandle;
-        table->info[table->used].flags = 0;
-        table->used++;
-
-        pidPtr[numPids] = phandle;
-
-
-        errorId = origErrorId;
-
-
-        if (inputId != -1) {
-            close(inputId);
-        }
-        if (outputId != -1) {
-            close(outputId);
-        }
-        inputId = pipeIds[0];
-        pipeIds[0] = pipeIds[1] = -1;
-    }
-    *pidArrayPtr = pidPtr;
-
-
-  cleanup:
-    if (inputId != -1) {
-        close(inputId);
-    }
-    if (lastOutputId != -1) {
-        close(lastOutputId);
-    }
-    if (errorId != -1) {
-        close(errorId);
-    }
-    Jim_Free(arg_array);
-
-    JimRestoreEnv(save_environ);
-
-    return numPids;
-
-
-  error:
-    if ((inPipePtr != NULL) && (*inPipePtr != -1)) {
-        close(*inPipePtr);
-        *inPipePtr = -1;
-    }
-    if ((outPipePtr != NULL) && (*outPipePtr != -1)) {
-        close(*outPipePtr);
-        *outPipePtr = -1;
-    }
-    if ((errFilePtr != NULL) && (*errFilePtr != -1)) {
-        close(*errFilePtr);
-        *errFilePtr = -1;
-    }
-    if (pipeIds[0] != -1) {
-        close(pipeIds[0]);
-    }
-    if (pipeIds[1] != -1) {
-        close(pipeIds[1]);
-    }
-    if (pidPtr != NULL) {
-        for (i = 0; i < numPids; i++) {
-            if (pidPtr[i] != JIM_BAD_PHANDLE) {
-                JimDetachPids(table, 1, &pidPtr[i]);
-            }
-        }
-        Jim_Free(pidPtr);
-    }
-    numPids = -1;
-    goto cleanup;
-}
-
-
-static int JimCleanupChildren(Jim_Interp *interp, int numPids, phandle_t *pidPtr, Jim_Obj *errStrObj)
-{
-    struct WaitInfoTable *table = Jim_CmdPrivData(interp);
-    int result = JIM_OK;
-    int i;
-
-
-    for (i = 0; i < numPids; i++) {
-        int waitStatus = 0;
-        long pid = JimWaitForProcess(table, pidPtr[i], &waitStatus);
-        if (pid > 0) {
-            if (JimCheckWaitStatus(interp, pid, waitStatus, errStrObj) != JIM_OK) {
-                result = JIM_ERR;
-            }
-        }
-    }
-    Jim_Free(pidPtr);
-
-    return result;
-}
-
-int Jim_execInit(Jim_Interp *interp)
-{
-    struct WaitInfoTable *waitinfo;
-
-    Jim_PackageProvideCheck(interp, "exec");
-
-    waitinfo = JimAllocWaitInfoTable();
-    Jim_CreateCommand(interp, "exec", Jim_ExecCmd, waitinfo, JimFreeWaitInfoTable);
-    waitinfo->refcount++;
-    Jim_CreateCommand(interp, "wait", Jim_WaitCommand, waitinfo, JimFreeWaitInfoTable);
-    Jim_CreateCommand(interp, "pid", Jim_PidCommand, 0, 0);
-
-    return JIM_OK;
-}
-
-#if defined(__MINGW32__)
-
-
-static int
-JimWinFindExecutable(const char *originalName, char fullPath[MAX_PATH])
-{
-    int i;
-    static char extensions[][5] = {".exe", "", ".bat"};
-
-    for (i = 0; i < (int) (sizeof(extensions) / sizeof(extensions[0])); i++) {
-        snprintf(fullPath, MAX_PATH, "%s%s", originalName, extensions[i]);
-
-        if (SearchPath(NULL, fullPath, NULL, MAX_PATH, fullPath, NULL) == 0) {
-            continue;
-        }
-        if (GetFileAttributes(fullPath) & FILE_ATTRIBUTE_DIRECTORY) {
-            continue;
-        }
-        return 0;
-    }
-
-    return -1;
-}
-
-static char **JimSaveEnv(char **env)
-{
-    return env;
-}
-
-static void JimRestoreEnv(char **env)
-{
-    JimFreeEnv(env, Jim_GetEnviron());
-}
-
-static char **JimOriginalEnviron(void)
-{
-    return NULL;
-}
-
-static Jim_Obj *
-JimWinBuildCommandLine(Jim_Interp *interp, char **argv)
-{
-    char *start, *special;
-    int quote, i;
-
-    Jim_Obj *strObj = Jim_NewStringObj(interp, "", 0);
-
-    for (i = 0; argv[i]; i++) {
-        if (i > 0) {
-            Jim_AppendString(interp, strObj, " ", 1);
-        }
-
-        if (argv[i][0] == '\0') {
-            quote = 1;
-        }
-        else {
-            quote = 0;
-            for (start = argv[i]; *start != '\0'; start++) {
-                if (isspace(UCHAR(*start))) {
-                    quote = 1;
-                    break;
-                }
-            }
-        }
-        if (quote) {
-            Jim_AppendString(interp, strObj, "\"" , 1);
-        }
-
-        start = argv[i];
-        for (special = argv[i]; ; ) {
-            if ((*special == '\\') && (special[1] == '\\' ||
-                    special[1] == '"' || (quote && special[1] == '\0'))) {
-                Jim_AppendString(interp, strObj, start, special - start);
-                start = special;
-                while (1) {
-                    special++;
-                    if (*special == '"' || (quote && *special == '\0')) {
-
-                        Jim_AppendString(interp, strObj, start, special - start);
-                        break;
-                    }
-                    if (*special != '\\') {
-                        break;
-                    }
-                }
-                Jim_AppendString(interp, strObj, start, special - start);
-                start = special;
-            }
-            if (*special == '"') {
-        if (special == start) {
-            Jim_AppendString(interp, strObj, "\"", 1);
-        }
-        else {
-            Jim_AppendString(interp, strObj, start, special - start);
-        }
-                Jim_AppendString(interp, strObj, "\\\"", 2);
-                start = special + 1;
-            }
-            if (*special == '\0') {
-                break;
-            }
-            special++;
-        }
-        Jim_AppendString(interp, strObj, start, special - start);
-        if (quote) {
-            Jim_AppendString(interp, strObj, "\"", 1);
-        }
-    }
-    return strObj;
-}
-
-static phandle_t
-JimStartWinProcess(Jim_Interp *interp, char **argv, char **env, int inputId, int outputId, int errorId)
-{
-    STARTUPINFO startInfo;
-    PROCESS_INFORMATION procInfo;
-    HANDLE hProcess;
-    char execPath[MAX_PATH];
-    phandle_t phandle = INVALID_HANDLE_VALUE;
-    Jim_Obj *cmdLineObj;
-    char *winenv;
-
-    if (JimWinFindExecutable(argv[0], execPath) < 0) {
-        return phandle;
-    }
-    argv[0] = execPath;
-
-    hProcess = GetCurrentProcess();
-    cmdLineObj = JimWinBuildCommandLine(interp, argv);
-
-
-    ZeroMemory(&startInfo, sizeof(startInfo));
-    startInfo.cb = sizeof(startInfo);
-    startInfo.dwFlags   = STARTF_USESTDHANDLES;
-    startInfo.hStdInput = INVALID_HANDLE_VALUE;
-    startInfo.hStdOutput= INVALID_HANDLE_VALUE;
-    startInfo.hStdError = INVALID_HANDLE_VALUE;
-
-    if (inputId == -1) {
-        inputId = _fileno(stdin);
-    }
-    DuplicateHandle(hProcess, (HANDLE)_get_osfhandle(inputId), hProcess, &startInfo.hStdInput,
-            0, TRUE, DUPLICATE_SAME_ACCESS);
-    if (startInfo.hStdInput == INVALID_HANDLE_VALUE) {
-        goto end;
-    }
-
-    if (outputId == -1) {
-        outputId = _fileno(stdout);
-    }
-    DuplicateHandle(hProcess, (HANDLE)_get_osfhandle(outputId), hProcess, &startInfo.hStdOutput,
-            0, TRUE, DUPLICATE_SAME_ACCESS);
-    if (startInfo.hStdOutput == INVALID_HANDLE_VALUE) {
-        goto end;
-    }
-
-
-    if (errorId == -1) {
-        errorId = _fileno(stderr);
-    }
-    DuplicateHandle(hProcess, (HANDLE)_get_osfhandle(errorId), hProcess, &startInfo.hStdError,
-            0, TRUE, DUPLICATE_SAME_ACCESS);
-    if (startInfo.hStdError == INVALID_HANDLE_VALUE) {
-        goto end;
-    }
-
-    if (env == NULL) {
-
-        winenv = NULL;
-    }
-    else if (env[0] == NULL) {
-        winenv = (char *)"\0";
-    }
-    else {
-        winenv = env[0];
-    }
-
-    if (!CreateProcess(NULL, (char *)Jim_String(cmdLineObj), NULL, NULL, TRUE,
-            0, winenv, NULL, &startInfo, &procInfo)) {
-        goto end;
-    }
-
-
-    WaitForInputIdle(procInfo.hProcess, 5000);
-    CloseHandle(procInfo.hThread);
-
-    phandle = procInfo.hProcess;
-
-    end:
-    Jim_FreeNewObj(interp, cmdLineObj);
-    if (startInfo.hStdInput != INVALID_HANDLE_VALUE) {
-        CloseHandle(startInfo.hStdInput);
-    }
-    if (startInfo.hStdOutput != INVALID_HANDLE_VALUE) {
-        CloseHandle(startInfo.hStdOutput);
-    }
-    if (startInfo.hStdError != INVALID_HANDLE_VALUE) {
-        CloseHandle(startInfo.hStdError);
-    }
-    return phandle;
-}
-
-#else
-
-static char **JimOriginalEnviron(void)
-{
-    return Jim_GetEnviron();
-}
-
-static char **JimSaveEnv(char **env)
-{
-    char **saveenv = Jim_GetEnviron();
-    Jim_SetEnviron(env);
-    return saveenv;
-}
-
-static void JimRestoreEnv(char **env)
-{
-    JimFreeEnv(Jim_GetEnviron(), env);
-    Jim_SetEnviron(env);
-}
-#endif
-#endif
-
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <time.h>
-
-
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-
-struct clock_options {
-    int gmt;
-    const char *format;
-};
-
-static int parse_clock_options(Jim_Interp *interp, int argc, Jim_Obj *const *argv, struct clock_options *opts)
-{
-    static const char * const options[] = { "-gmt", "-format", NULL };
-    enum { OPT_GMT, OPT_FORMAT, };
-    int i;
-
-    for (i = 0; i < argc; i += 2) {
-        int option;
-        if (Jim_GetEnum(interp, argv[i], options, &option, NULL, JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK) {
-            return JIM_ERR;
-        }
-        switch (option) {
-            case OPT_GMT:
-                if (Jim_GetBoolean(interp, argv[i + 1], &opts->gmt) != JIM_OK) {
-                    return JIM_ERR;
-                }
-                break;
-            case OPT_FORMAT:
-                opts->format = Jim_String(argv[i + 1]);
-                break;
-        }
-    }
-    return JIM_OK;
-}
-
-static int clock_cmd_format(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-
-    char buf[100];
-    time_t t;
-    jim_wide seconds;
-    struct clock_options options = { 0, "%a %b %d %H:%M:%S %Z %Y" };
-    struct tm *tm;
-
-    if (Jim_GetWide(interp, argv[0], &seconds) != JIM_OK) {
-        return JIM_ERR;
-    }
-    if (argc % 2 == 0) {
-        return -1;
-    }
-    if (parse_clock_options(interp, argc - 1, argv + 1, &options) == JIM_ERR) {
-        return JIM_ERR;
-    }
-
-    t = seconds;
-    tm = options.gmt ? gmtime(&t) : localtime(&t);
-
-    if (tm == NULL || strftime(buf, sizeof(buf), options.format, tm) == 0) {
-        Jim_SetResultString(interp, "format string too long or invalid time", -1);
-        return JIM_ERR;
-    }
-
-    Jim_SetResultString(interp, buf, -1);
-
-    return JIM_OK;
-}
-
-#ifdef HAVE_STRPTIME
-static time_t jim_timegm(const struct tm *tm)
-{
-    int m = tm->tm_mon + 1;
-    int y = 1900 + tm->tm_year - (m <= 2);
-    int era = (y >= 0 ? y : y - 399) / 400;
-    unsigned yoe = (unsigned)(y - era * 400);
-    unsigned doy = (153 * (m + (m > 2 ? -3 : 9)) + 2) / 5 + tm->tm_mday - 1;
-    unsigned doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
-    long days = (era * 146097 + (int)doe - 719468);
-    int secs = tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec;
-
-    return days * 24 * 60 * 60 + secs;
-}
-
-static int clock_cmd_scan(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    char *pt;
-    struct tm tm;
-    time_t now = time(NULL);
-
-    struct clock_options options = { 0, NULL };
-
-    if (argc % 2 == 0) {
-        return -1;
-    }
-
-    if (parse_clock_options(interp, argc - 1, argv + 1, &options) == JIM_ERR) {
-        return JIM_ERR;
-    }
-    if (options.format == NULL) {
-        return -1;
-    }
-
-    localtime_r(&now, &tm);
-
-    pt = strptime(Jim_String(argv[0]), options.format, &tm);
-    if (pt == 0 || *pt != 0) {
-        Jim_SetResultString(interp, "Failed to parse time according to format", -1);
-        return JIM_ERR;
-    }
-
-
-    tm.tm_isdst = options.gmt ? 0 : -1;
-    Jim_SetResultInt(interp, options.gmt ? jim_timegm(&tm) : mktime(&tm));
-
-    return JIM_OK;
-}
-#endif
-
-static int clock_cmd_seconds(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_SetResultInt(interp, Jim_GetTimeUsec(CLOCK_REALTIME) / 1000000);
-    return JIM_OK;
-}
-
-static int clock_cmd_clicks(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_SetResultInt(interp, Jim_GetTimeUsec(CLOCK_MONOTONIC_RAW));
-    return JIM_OK;
-}
-
-static int clock_cmd_micros(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_SetResultInt(interp, Jim_GetTimeUsec(CLOCK_REALTIME));
-    return JIM_OK;
-}
-
-static int clock_cmd_millis(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_SetResultInt(interp, Jim_GetTimeUsec(CLOCK_REALTIME) / 1000);
-    return JIM_OK;
-}
-
-static const jim_subcmd_type clock_command_table[] = {
-    {   "clicks",
-        NULL,
-        clock_cmd_clicks,
-        0,
-        0,
-
-    },
-    {   "format",
-        "seconds ?-format string? ?-gmt boolean?",
-        clock_cmd_format,
-        1,
-        5,
-
-    },
-    {   "microseconds",
-        NULL,
-        clock_cmd_micros,
-        0,
-        0,
-
-    },
-    {   "milliseconds",
-        NULL,
-        clock_cmd_millis,
-        0,
-        0,
-
-    },
-#ifdef HAVE_STRPTIME
-    {   "scan",
-        "str -format format ?-gmt boolean?",
-        clock_cmd_scan,
-        3,
-        5,
-
-    },
-#endif
-    {   "seconds",
-        NULL,
-        clock_cmd_seconds,
-        0,
-        0,
-
-    },
-    { NULL }
-};
-
-int Jim_clockInit(Jim_Interp *interp)
-{
-    Jim_PackageProvideCheck(interp, "clock");
-    Jim_CreateCommand(interp, "clock", Jim_SubCmdProc, (void *)clock_command_table, NULL);
-    return JIM_OK;
-}
-
-#include <limits.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <errno.h>
-
-
-static int array_cmd_exists(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-
-    Jim_Obj *dictObj = Jim_GetVariable(interp, argv[0], JIM_UNSHARED);
-    Jim_SetResultInt(interp, dictObj && Jim_DictSize(interp, dictObj) != -1);
-    return JIM_OK;
-}
-
-static int array_cmd_get(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
-    Jim_Obj *patternObj;
-
-    if (!objPtr) {
-        return JIM_OK;
-    }
-
-    patternObj = (argc == 1) ? NULL : argv[1];
-
-
-    if (patternObj == NULL || Jim_CompareStringImmediate(interp, patternObj, "*")) {
-        if (Jim_IsList(objPtr) && Jim_ListLength(interp, objPtr) % 2 == 0) {
-
-            Jim_SetResult(interp, objPtr);
-            return JIM_OK;
-        }
-    }
-
-    return Jim_DictMatchTypes(interp, objPtr, patternObj, JIM_DICTMATCH_KEYS, JIM_DICTMATCH_KEYS | JIM_DICTMATCH_VALUES);
-}
-
-static int array_cmd_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
-
-    if (!objPtr) {
-        return JIM_OK;
-    }
-
-    return Jim_DictMatchTypes(interp, objPtr, argc == 1 ? NULL : argv[1], JIM_DICTMATCH_KEYS, JIM_DICTMATCH_KEYS);
-}
-
-static int array_cmd_unset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int i;
-    int len;
-    Jim_Obj *resultObj;
-    Jim_Obj *objPtr;
-    Jim_Obj **dictValuesObj;
-
-    if (argc == 1 || Jim_CompareStringImmediate(interp, argv[1], "*")) {
-
-        Jim_UnsetVariable(interp, argv[0], JIM_NONE);
-        return JIM_OK;
-    }
-
-    objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
-
-    if (objPtr == NULL) {
-
-        return JIM_OK;
-    }
-
-    dictValuesObj = Jim_DictPairs(interp, objPtr, &len);
-    if (dictValuesObj == NULL) {
-
-        Jim_SetResultString(interp, "", -1);
-        return JIM_OK;
-    }
-
-
-    resultObj = Jim_NewDictObj(interp, NULL, 0);
-
-    for (i = 0; i < len; i += 2) {
-        if (!Jim_StringMatchObj(interp, argv[1], dictValuesObj[i], 0)) {
-            Jim_DictAddElement(interp, resultObj, dictValuesObj[i], dictValuesObj[i + 1]);
-        }
-    }
-
-    Jim_SetVariable(interp, argv[0], resultObj);
-    return JIM_OK;
-}
-
-static int array_cmd_size(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *objPtr;
-    int len = 0;
-
-
-    objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
-    if (objPtr) {
-        len = Jim_DictSize(interp, objPtr);
-        if (len < 0) {
-
-            Jim_SetResultInt(interp, 0);
-            return JIM_OK;
-        }
-    }
-
-    Jim_SetResultInt(interp, len);
-
-    return JIM_OK;
-}
-
-static int array_cmd_stat(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
-    if (objPtr) {
-        return Jim_DictInfo(interp, objPtr);
-    }
-    Jim_SetResultFormatted(interp, "\"%#s\" isn't an array", argv[0], NULL);
-    return JIM_ERR;
-}
-
-static int array_cmd_set(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int i;
-    int len;
-    Jim_Obj *listObj = argv[1];
-    Jim_Obj *dictObj;
-
-    len = Jim_ListLength(interp, listObj);
-    if (len % 2) {
-        Jim_SetResultString(interp, "list must have an even number of elements", -1);
-        return JIM_ERR;
-    }
-
-    dictObj = Jim_GetVariable(interp, argv[0], JIM_UNSHARED);
-    if (!dictObj) {
-
-        return Jim_SetVariable(interp, argv[0], listObj);
-    }
-    else if (Jim_DictSize(interp, dictObj) < 0) {
-        return JIM_ERR;
-    }
-
-    if (Jim_IsShared(dictObj)) {
-        dictObj = Jim_DuplicateObj(interp, dictObj);
-    }
-
-    for (i = 0; i < len; i += 2) {
-        Jim_Obj *nameObj;
-        Jim_Obj *valueObj;
-
-        Jim_ListIndex(interp, listObj, i, &nameObj, JIM_NONE);
-        Jim_ListIndex(interp, listObj, i + 1, &valueObj, JIM_NONE);
-
-        Jim_DictAddElement(interp, dictObj, nameObj, valueObj);
-    }
-    return Jim_SetVariable(interp, argv[0], dictObj);
-}
-
-static const jim_subcmd_type array_command_table[] = {
-        {       "exists",
-                "arrayName",
-                array_cmd_exists,
-                1,
-                1,
-
-        },
-        {       "get",
-                "arrayName ?pattern?",
-                array_cmd_get,
-                1,
-                2,
-
-        },
-        {       "names",
-                "arrayName ?pattern?",
-                array_cmd_names,
-                1,
-                2,
-
-        },
-        {       "set",
-                "arrayName list",
-                array_cmd_set,
-                2,
-                2,
-
-        },
-        {       "size",
-                "arrayName",
-                array_cmd_size,
-                1,
-                1,
-
-        },
-        {       "stat",
-                "arrayName",
-                array_cmd_stat,
-                1,
-                1,
-
-        },
-        {       "unset",
-                "arrayName ?pattern?",
-                array_cmd_unset,
-                1,
-                2,
-
-        },
-        {       NULL
-        }
-};
-
-int Jim_arrayInit(Jim_Interp *interp)
-{
-    Jim_PackageProvideCheck(interp, "array");
-    Jim_CreateCommand(interp, "array", Jim_SubCmdProc, (void *)array_command_table, NULL);
-    return JIM_OK;
-}
-int Jim_InitStaticExtensions(Jim_Interp *interp)
-{
-extern int Jim_bootstrapInit(Jim_Interp *);
-extern int Jim_aioInit(Jim_Interp *);
-extern int Jim_readdirInit(Jim_Interp *);
-extern int Jim_regexpInit(Jim_Interp *);
-extern int Jim_fileInit(Jim_Interp *);
-extern int Jim_globInit(Jim_Interp *);
-extern int Jim_execInit(Jim_Interp *);
-extern int Jim_clockInit(Jim_Interp *);
-extern int Jim_arrayInit(Jim_Interp *);
-extern int Jim_stdlibInit(Jim_Interp *);
-extern int Jim_tclcompatInit(Jim_Interp *);
-Jim_bootstrapInit(interp);
-Jim_aioInit(interp);
-Jim_readdirInit(interp);
-Jim_regexpInit(interp);
-Jim_fileInit(interp);
-Jim_globInit(interp);
-Jim_execInit(interp);
-Jim_clockInit(interp);
-Jim_arrayInit(interp);
-Jim_stdlibInit(interp);
-Jim_tclcompatInit(interp);
-return JIM_OK;
-}
-#ifndef JIM_TINY
-#define JIM_OPTIMIZATION
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <string.h>
-#include <stdarg.h>
-#include <ctype.h>
-#include <limits.h>
-#include <assert.h>
-#include <errno.h>
-#include <time.h>
-#include <setjmp.h>
-
-
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-#ifdef HAVE_EXECINFO_H
-#include <execinfo.h>
-#endif
-#ifdef HAVE_CRT_EXTERNS_H
-#include <crt_externs.h>
-#endif
-
-
-#include <math.h>
-
-
-
-
-
-#ifndef TCL_LIBRARY
-#define TCL_LIBRARY "."
-#endif
-#ifndef TCL_PLATFORM_OS
-#define TCL_PLATFORM_OS "unknown"
-#endif
-#ifndef TCL_PLATFORM_PLATFORM
-#define TCL_PLATFORM_PLATFORM "unknown"
-#endif
-#ifndef TCL_PLATFORM_PATH_SEPARATOR
-#define TCL_PLATFORM_PATH_SEPARATOR ":"
-#endif
-
-
-
-
-
-
-
-#ifdef JIM_MAINTAINER
-#define JIM_DEBUG_COMMAND
-#define JIM_DEBUG_PANIC
-#endif
-
-
-
-#define JIM_INTEGER_SPACE 24
-
-#if defined(DEBUG_SHOW_SCRIPT) || defined(DEBUG_SHOW_SCRIPT_TOKENS) || defined(JIM_DEBUG_COMMAND) || defined(DEBUG_SHOW_SUBST)
-static const char *jim_tt_name(int type);
-#endif
-
-#ifdef JIM_DEBUG_PANIC
-static void JimPanicDump(int fail_condition, const char *fmt, ...);
-#define JimPanic(X) JimPanicDump X
-#else
-#define JimPanic(X)
-#endif
-
-#ifdef JIM_OPTIMIZATION
-static int JimIsWide(Jim_Obj *objPtr);
-#define JIM_IF_OPTIM(X) X
-#else
-#define JIM_IF_OPTIM(X)
-#endif
-
-
-static char JimEmptyStringRep[] = "";
-
-static void JimFreeCallFrame(Jim_Interp *interp, Jim_CallFrame *cf, int action);
-static int ListSetIndex(Jim_Interp *interp, Jim_Obj *listPtr, int listindex, Jim_Obj *newObjPtr,
-    int flags);
-static int Jim_ListIndices(Jim_Interp *interp, Jim_Obj *listPtr, Jim_Obj *const *indexv, int indexc,
-    Jim_Obj **resultObj, int flags);
-static int JimDeleteLocalProcs(Jim_Interp *interp, Jim_Stack *localCommands);
-static Jim_Obj *JimExpandDictSugar(Jim_Interp *interp, Jim_Obj *objPtr);
-static void SetDictSubstFromAny(Jim_Interp *interp, Jim_Obj *objPtr);
-static void JimSetFailedEnumResult(Jim_Interp *interp, const char *arg, const char *badtype,
-    const char *prefix, const char *const *tablePtr, const char *name);
-static int JimCallProcedure(Jim_Interp *interp, Jim_Cmd *cmd, int argc, Jim_Obj *const *argv);
-static int JimGetWideNoErr(Jim_Interp *interp, Jim_Obj *objPtr, jim_wide * widePtr);
-static int JimSign(jim_wide w);
-static void JimPrngSeed(Jim_Interp *interp, unsigned char *seed, int seedLen);
-static void JimRandomBytes(Jim_Interp *interp, void *dest, unsigned int len);
-static int JimSetNewVariable(Jim_HashTable *ht, Jim_Obj *nameObjPtr, Jim_VarVal *vv);
-static Jim_VarVal *JimFindVariable(Jim_HashTable *ht, Jim_Obj *nameObjPtr);
-static int SetVariableFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
-
-#define JIM_DICT_SUGAR 100
-
-
-
-
-#define JimWideValue(objPtr) (objPtr)->internalRep.wideValue
-
-#define JimObjTypeName(O) ((O)->typePtr ? (O)->typePtr->name : "none")
-
-static int utf8_tounicode_case(const char *s, int *uc, int upper)
-{
-    int l = utf8_tounicode(s, uc);
-    if (upper) {
-        *uc = utf8_upper(*uc);
-    }
-    return l;
-}
-
-static Jim_Obj *JimPushInterpObjImpl(Jim_Obj **iop, Jim_Obj *no)
-{
-    Jim_Obj *io = *iop;
-    Jim_IncrRefCount(no);
-    *iop = no;
-    return io;
-}
-
-#define JimPushInterpObj(IO, NO) JimPushInterpObjImpl(&(IO), NO)
-#define JimPopInterpObj(I, IO, SO) do { Jim_DecrRefCount(I, IO); IO = SO; } while (0)
-
-
-#define JIM_CHARSET_SCAN 2
-#define JIM_CHARSET_GLOB 0
-
-static const char *JimCharsetMatch(const char *pattern, int plen, int c, int flags)
-{
-    int not = 0;
-    int pchar;
-    int match = 0;
-    int nocase = 0;
-    int n;
-
-    if (flags & JIM_NOCASE) {
-        nocase++;
-        c = utf8_upper(c);
-    }
-
-    if (flags & JIM_CHARSET_SCAN) {
-        if (*pattern == '^') {
-            not++;
-            pattern++;
-            plen--;
-        }
-
-
-        if (*pattern == ']') {
-            goto first;
-        }
-    }
-
-    while (plen && *pattern != ']') {
-
-        if (pattern[0] == '\\') {
-first:
-            n = utf8_tounicode_case(pattern, &pchar, nocase);
-            pattern += n;
-            plen -= n;
-        }
-        else {
-
-            int start;
-            int end;
-
-            n = utf8_tounicode_case(pattern, &start, nocase);
-            pattern += n;
-            plen -= n;
-            if (pattern[0] == '-' && plen > 1) {
-
-                n = 1 + utf8_tounicode_case(pattern + 1, &end, nocase);
-                pattern += n;
-                plen -= n;
-
-
-                if ((c >= start && c <= end) || (c >= end && c <= start)) {
-                    match = 1;
-                }
-                continue;
-            }
-            pchar = start;
-        }
-
-        if (pchar == c) {
-            match = 1;
-        }
-    }
-    if (not) {
-        match = !match;
-    }
-
-    return match ? pattern : NULL;
-}
-
-
-
-static int JimGlobMatch(const char *pattern, int plen, const char *string, int slen, int nocase)
-{
-    int c;
-    int pchar;
-    int n;
-    const char *p;
-    while (plen) {
-        switch (pattern[0]) {
-            case '*':
-                while (pattern[1] == '*' && plen) {
-                    pattern++;
-                    plen--;
-                }
-                pattern++;
-                plen--;
-                if (!plen) {
-                    return 1;
-                }
-                while (slen) {
-
-                    if (JimGlobMatch(pattern, plen, string, slen, nocase))
-                        return 1;
-                    n = utf8_tounicode(string, &c);
-                    string += n;
-                    slen -= n;
-                }
-                return 0;
-
-            case '?':
-                n = utf8_tounicode(string, &c);
-                string += n;
-                slen -= n;
-                break;
-
-            case '[': {
-                    n = utf8_tounicode(string, &c);
-                    string += n;
-                    slen -= n;
-                    p = JimCharsetMatch(pattern + 1, plen - 1, c, nocase ? JIM_NOCASE : 0);
-                    if (!p) {
-                        return 0;
-                    }
-                    plen -= p - pattern;
-                    pattern = p;
-
-                    if (!plen) {
-
-                        continue;
-                    }
-                    break;
-                }
-            case '\\':
-                if (pattern[1]) {
-                    pattern++;
-                    plen--;
-                }
-
-            default:
-                n = utf8_tounicode_case(string, &c, nocase);
-                string += n;
-                slen -= n;
-                utf8_tounicode_case(pattern, &pchar, nocase);
-                if (pchar != c) {
-                    return 0;
-                }
-                break;
-        }
-        n = utf8_tounicode_case(pattern, &pchar, nocase);
-        pattern += n;
-        plen -= n;
-        if (!slen) {
-            while (*pattern == '*' && plen) {
-                pattern++;
-                plen--;
-            }
-            break;
-        }
-    }
-    if (!plen && !slen) {
-        return 1;
-    }
-    return 0;
-}
-
-static int JimStringCompareUtf8(const char *s1, int l1, const char *s2, int l2, int nocase)
-{
-    int minlen = l1;
-    if (l2 < l1) {
-        minlen = l2;
-    }
-    while (minlen) {
-        int c1, c2;
-        s1 += utf8_tounicode_case(s1, &c1, nocase);
-        s2 += utf8_tounicode_case(s2, &c2, nocase);
-        if (c1 != c2) {
-            return JimSign(c1 - c2);
-        }
-        minlen--;
-    }
-
-    if (l1 < l2) {
-        return -1;
-    }
-    if (l1 > l2) {
-        return 1;
-    }
-    return 0;
-}
-
-static int JimStringFirst(const char *s1, int l1, const char *s2, int l2, int idx)
-{
-    int i;
-    int l1bytelen;
-
-    if (!l1 || !l2 || l1 > l2) {
-        return -1;
-    }
-    if (idx < 0)
-        idx = 0;
-    s2 += utf8_index(s2, idx);
-
-    l1bytelen = utf8_index(s1, l1);
-
-    for (i = idx; i <= l2 - l1; i++) {
-        int c;
-        if (memcmp(s2, s1, l1bytelen) == 0) {
-            return i;
-        }
-        s2 += utf8_tounicode(s2, &c);
-    }
-    return -1;
-}
-
-static int JimStringLast(const char *s1, int l1, const char *s2, int l2)
-{
-    const char *p;
-
-    if (!l1 || !l2 || l1 > l2)
-        return -1;
-
-
-    for (p = s2 + l2 - 1; p != s2 - 1; p--) {
-        if (*p == *s1 && memcmp(s1, p, l1) == 0) {
-            return p - s2;
-        }
-    }
-    return -1;
-}
-
-#ifdef JIM_UTF8
-static int JimStringLastUtf8(const char *s1, int l1, const char *s2, int l2)
-{
-    int n = JimStringLast(s1, utf8_index(s1, l1), s2, utf8_index(s2, l2));
-    if (n > 0) {
-        n = utf8_strlen(s2, n);
-    }
-    return n;
-}
-#endif
-
-static int JimCheckConversion(const char *str, const char *endptr)
-{
-    if (str[0] == '\0' || str == endptr) {
-        return JIM_ERR;
-    }
-
-    if (endptr[0] != '\0') {
-        while (*endptr) {
-            if (!isspace(UCHAR(*endptr))) {
-                return JIM_ERR;
-            }
-            endptr++;
-        }
-    }
-    return JIM_OK;
-}
-
-static int JimNumberBase(const char *str, int *base, int *sign)
-{
-    int i = 0;
-
-    *base = 0;
-
-    while (isspace(UCHAR(str[i]))) {
-        i++;
-    }
-
-    if (str[i] == '-') {
-        *sign = -1;
-        i++;
-    }
-    else {
-        if (str[i] == '+') {
-            i++;
-        }
-        *sign = 1;
-    }
-
-    if (str[i] != '0') {
-
-        return 0;
-    }
-
-
-    switch (str[i + 1]) {
-        case 'x': case 'X': *base = 16; break;
-        case 'o': case 'O': *base = 8; break;
-        case 'b': case 'B': *base = 2; break;
-        case 'd': case 'D': *base = 10; break;
-        default: return 0;
-    }
-    i += 2;
-
-    if (str[i] != '-' && str[i] != '+' && !isspace(UCHAR(str[i]))) {
-
-        return i;
-    }
-
-    *base = 0;
-    return 0;
-}
-
-static long jim_strtol(const char *str, char **endptr)
-{
-    int sign;
-    int base;
-    int i = JimNumberBase(str, &base, &sign);
-
-    if (base != 0) {
-        long value = strtol(str + i, endptr, base);
-        if (endptr == NULL || *endptr != str + i) {
-            return value * sign;
-        }
-    }
-
-
-    return strtol(str, endptr, 10);
-}
-
-
-static jim_wide jim_strtoull(const char *str, char **endptr)
-{
-#ifdef HAVE_LONG_LONG
-    int sign;
-    int base;
-    int i = JimNumberBase(str, &base, &sign);
-
-    if (base != 0) {
-        jim_wide value = strtoull(str + i, endptr, base);
-        if (endptr == NULL || *endptr != str + i) {
-            return value * sign;
-        }
-    }
-
-
-    return strtoull(str, endptr, 10);
-#else
-    return (unsigned long)jim_strtol(str, endptr);
-#endif
-}
-
-int Jim_StringToWide(const char *str, jim_wide * widePtr, int base)
-{
-    char *endptr;
-
-    if (base) {
-        *widePtr = strtoull(str, &endptr, base);
-    }
-    else {
-        *widePtr = jim_strtoull(str, &endptr);
-    }
-
-    return JimCheckConversion(str, endptr);
-}
-
-int Jim_StringToDouble(const char *str, double *doublePtr)
-{
-    char *endptr;
-
-
-    errno = 0;
-
-    *doublePtr = strtod(str, &endptr);
-
-    return JimCheckConversion(str, endptr);
-}
-
-static jim_wide JimPowWide(jim_wide b, jim_wide e)
-{
-    jim_wide res = 1;
-
-
-    if (b == 1) {
-
-        return 1;
-    }
-    if (e < 0) {
-        if (b != -1) {
-            return 0;
-        }
-        e = -e;
-    }
-    while (e)
-    {
-        if (e & 1) {
-            res *= b;
-        }
-        e >>= 1;
-        b *= b;
-    }
-    return res;
-}
-
-#ifdef JIM_DEBUG_PANIC
-static void JimPanicDump(int condition, const char *fmt, ...)
-{
-    va_list ap;
-
-    if (!condition) {
-        return;
-    }
-
-    va_start(ap, fmt);
-
-    fprintf(stderr, "\nJIM INTERPRETER PANIC: ");
-    vfprintf(stderr, fmt, ap);
-    fprintf(stderr, "\n\n");
-    va_end(ap);
-
-#if defined(HAVE_BACKTRACE)
-    {
-        void *array[40];
-        int size, i;
-        char **strings;
-
-        size = backtrace(array, 40);
-        strings = backtrace_symbols(array, size);
-        for (i = 0; i < size; i++)
-            fprintf(stderr, "[backtrace] %s\n", strings[i]);
-        fprintf(stderr, "[backtrace] Include the above lines and the output\n");
-        fprintf(stderr, "[backtrace] of 'nm <executable>' in the bug report.\n");
-    }
-#endif
-
-    exit(1);
-}
-#endif
-
-
-void *JimDefaultAllocator(void *ptr, size_t size)
-{
-    if (size == 0) {
-        free(ptr);
-        return NULL;
-    }
-    else {
-        void *p = realloc(ptr, size);
-        if( p==0 ){
-            fprintf(stderr,"Out of memory\n");
-            exit(1);
-        }
-        return p;
-    }
-}
-
-void *(*Jim_Allocator)(void *ptr, size_t size) = JimDefaultAllocator;
-
-char *Jim_StrDup(const char *s)
-{
-    return Jim_StrDupLen(s, strlen(s));
-}
-
-char *Jim_StrDupLen(const char *s, int l)
-{
-    char *copy = Jim_Alloc(l + 1);
-
-    memcpy(copy, s, l);
-    copy[l] = 0;
-    return copy;
-}
-
-
-jim_wide Jim_GetTimeUsec(unsigned type)
-{
-    long long now;
-    struct timeval tv;
-
-#if defined(HAVE_CLOCK_GETTIME)
-    struct timespec ts;
-
-    if (clock_gettime(type, &ts) == 0) {
-        now = ts.tv_sec * 1000000LL + ts.tv_nsec / 1000;
-    }
-    else
-#endif
-    {
-        gettimeofday(&tv, NULL);
-
-        now = tv.tv_sec * 1000000LL + tv.tv_usec;
-    }
-
-    return now;
-}
-
-
-
-
-
-static void JimExpandHashTableIfNeeded(Jim_HashTable *ht);
-static unsigned int JimHashTableNextPower(unsigned int size);
-static Jim_HashEntry *JimInsertHashEntry(Jim_HashTable *ht, const void *key, int replace);
-
-
-
-
-unsigned int Jim_IntHashFunction(unsigned int key)
-{
-    key += ~(key << 15);
-    key ^= (key >> 10);
-    key += (key << 3);
-    key ^= (key >> 6);
-    key += ~(key << 11);
-    key ^= (key >> 16);
-    return key;
-}
-
-
-unsigned int Jim_GenHashFunction(const unsigned char *string, int length)
-{
-    unsigned result = 0;
-    string += length;
-    while (length--) {
-        result += (result << 3) + (unsigned char)(*--string);
-    }
-    return result;
-}
-
-
-
-static void JimResetHashTable(Jim_HashTable *ht)
-{
-    ht->table = NULL;
-    ht->size = 0;
-    ht->sizemask = 0;
-    ht->used = 0;
-    ht->collisions = 0;
-#ifdef JIM_RANDOMISE_HASH
-    ht->uniq = (rand() ^ time(NULL) ^ clock());
-#else
-    ht->uniq = 0;
-#endif
-}
-
-static void JimInitHashTableIterator(Jim_HashTable *ht, Jim_HashTableIterator *iter)
-{
-    iter->ht = ht;
-    iter->index = -1;
-    iter->entry = NULL;
-    iter->nextEntry = NULL;
-}
-
-
-int Jim_InitHashTable(Jim_HashTable *ht, const Jim_HashTableType *type, void *privDataPtr)
-{
-    JimResetHashTable(ht);
-    ht->type = type;
-    ht->privdata = privDataPtr;
-    return JIM_OK;
-}
-
-
-void Jim_ExpandHashTable(Jim_HashTable *ht, unsigned int size)
-{
-    Jim_HashTable n;
-    unsigned int realsize = JimHashTableNextPower(size), i;
-
-     if (size <= ht->used)
-        return;
-
-    Jim_InitHashTable(&n, ht->type, ht->privdata);
-    n.size = realsize;
-    n.sizemask = realsize - 1;
-    n.table = Jim_Alloc(realsize * sizeof(Jim_HashEntry *));
-
-    n.uniq = ht->uniq;
-
-
-    memset(n.table, 0, realsize * sizeof(Jim_HashEntry *));
-
-    n.used = ht->used;
-    for (i = 0; ht->used > 0; i++) {
-        Jim_HashEntry *he, *nextHe;
-
-        if (ht->table[i] == NULL)
-            continue;
-
-
-        he = ht->table[i];
-        while (he) {
-            unsigned int h;
-
-            nextHe = he->next;
-
-            h = Jim_HashKey(ht, he->key) & n.sizemask;
-            he->next = n.table[h];
-            n.table[h] = he;
-            ht->used--;
-
-            he = nextHe;
-        }
-    }
-    assert(ht->used == 0);
-    Jim_Free(ht->table);
-
-
-    *ht = n;
-}
-
-int Jim_AddHashEntry(Jim_HashTable *ht, const void *key, void *val)
-{
-    Jim_HashEntry *entry = JimInsertHashEntry(ht, key, 0);;
-    if (entry == NULL)
-        return JIM_ERR;
-
-
-    Jim_SetHashKey(ht, entry, key);
-    Jim_SetHashVal(ht, entry, val);
-    return JIM_OK;
-}
-
-
-int Jim_ReplaceHashEntry(Jim_HashTable *ht, const void *key, void *val)
-{
-    int existed;
-    Jim_HashEntry *entry;
-
-    entry = JimInsertHashEntry(ht, key, 1);
-    if (entry->key) {
-        if (ht->type->valDestructor && ht->type->valDup) {
-            void *newval = ht->type->valDup(ht->privdata, val);
-            ht->type->valDestructor(ht->privdata, entry->u.val);
-            entry->u.val = newval;
-        }
-        else {
-            Jim_FreeEntryVal(ht, entry);
-            Jim_SetHashVal(ht, entry, val);
-        }
-        existed = 1;
-    }
-    else {
-
-        Jim_SetHashKey(ht, entry, key);
-        Jim_SetHashVal(ht, entry, val);
-        existed = 0;
-    }
-
-    return existed;
-}
-
-int Jim_DeleteHashEntry(Jim_HashTable *ht, const void *key)
-{
-    if (ht->used) {
-        unsigned int h = Jim_HashKey(ht, key) & ht->sizemask;
-        Jim_HashEntry *prevHe = NULL;
-        Jim_HashEntry *he = ht->table[h];
-
-        while (he) {
-            if (Jim_CompareHashKeys(ht, key, he->key)) {
-
-                if (prevHe)
-                    prevHe->next = he->next;
-                else
-                    ht->table[h] = he->next;
-                ht->used--;
-                Jim_FreeEntryKey(ht, he);
-                Jim_FreeEntryVal(ht, he);
-                Jim_Free(he);
-                return JIM_OK;
-            }
-            prevHe = he;
-            he = he->next;
-        }
-    }
-
-    return JIM_ERR;
-}
-
-void Jim_ClearHashTable(Jim_HashTable *ht)
-{
-    unsigned int i;
-
-
-    for (i = 0; ht->used > 0; i++) {
-        Jim_HashEntry *he, *nextHe;
-
-        he = ht->table[i];
-        while (he) {
-            nextHe = he->next;
-            Jim_FreeEntryKey(ht, he);
-            Jim_FreeEntryVal(ht, he);
-            Jim_Free(he);
-            ht->used--;
-            he = nextHe;
-        }
-        ht->table[i] = NULL;
-    }
-}
-
-int Jim_FreeHashTable(Jim_HashTable *ht)
-{
-    Jim_ClearHashTable(ht);
-
-    Jim_Free(ht->table);
-
-    JimResetHashTable(ht);
-    return JIM_OK;
-}
-
-Jim_HashEntry *Jim_FindHashEntry(Jim_HashTable *ht, const void *key)
-{
-    Jim_HashEntry *he;
-    unsigned int h;
-
-    if (ht->used == 0)
-        return NULL;
-    h = Jim_HashKey(ht, key) & ht->sizemask;
-    he = ht->table[h];
-    while (he) {
-        if (Jim_CompareHashKeys(ht, key, he->key))
-            return he;
-        he = he->next;
-    }
-    return NULL;
-}
-
-Jim_HashTableIterator *Jim_GetHashTableIterator(Jim_HashTable *ht)
-{
-    Jim_HashTableIterator *iter = Jim_Alloc(sizeof(*iter));
-    JimInitHashTableIterator(ht, iter);
-    return iter;
-}
-
-Jim_HashEntry *Jim_NextHashEntry(Jim_HashTableIterator *iter)
-{
-    while (1) {
-        if (iter->entry == NULL) {
-            iter->index++;
-            if (iter->index >= (signed)iter->ht->size)
-                break;
-            iter->entry = iter->ht->table[iter->index];
-        }
-        else {
-            iter->entry = iter->nextEntry;
-        }
-        if (iter->entry) {
-            iter->nextEntry = iter->entry->next;
-            return iter->entry;
-        }
-    }
-    return NULL;
-}
-
-
-
-
-static void JimExpandHashTableIfNeeded(Jim_HashTable *ht)
-{
-    if (ht->size == 0)
-        Jim_ExpandHashTable(ht, JIM_HT_INITIAL_SIZE);
-    if (ht->size == ht->used)
-        Jim_ExpandHashTable(ht, ht->size * 2);
-}
-
-
-static unsigned int JimHashTableNextPower(unsigned int size)
-{
-    unsigned int i = JIM_HT_INITIAL_SIZE;
-
-    if (size >= 2147483648U)
-        return 2147483648U;
-    while (1) {
-        if (i >= size)
-            return i;
-        i *= 2;
-    }
-}
-
-static Jim_HashEntry *JimInsertHashEntry(Jim_HashTable *ht, const void *key, int replace)
-{
-    unsigned int h;
-    Jim_HashEntry *he;
-
-
-    JimExpandHashTableIfNeeded(ht);
-
-
-    h = Jim_HashKey(ht, key) & ht->sizemask;
-
-    he = ht->table[h];
-    while (he) {
-        if (Jim_CompareHashKeys(ht, key, he->key))
-            return replace ? he : NULL;
-        he = he->next;
-    }
-
-
-    he = Jim_Alloc(sizeof(*he));
-    he->next = ht->table[h];
-    ht->table[h] = he;
-    ht->used++;
-    he->key = NULL;
-
-    return he;
-}
-
-
-
-static unsigned int JimStringCopyHTHashFunction(const void *key)
-{
-    return Jim_GenHashFunction(key, strlen(key));
-}
-
-static void *JimStringCopyHTDup(void *privdata, const void *key)
-{
-    return Jim_StrDup(key);
-}
-
-static int JimStringCopyHTKeyCompare(void *privdata, const void *key1, const void *key2)
-{
-    return strcmp(key1, key2) == 0;
-}
-
-static void JimStringCopyHTKeyDestructor(void *privdata, void *key)
-{
-    Jim_Free(key);
-}
-
-static const Jim_HashTableType JimPackageHashTableType = {
-    JimStringCopyHTHashFunction,
-    JimStringCopyHTDup,
-    NULL,
-    JimStringCopyHTKeyCompare,
-    JimStringCopyHTKeyDestructor,
-    NULL
-};
-
-typedef struct AssocDataValue
-{
-    Jim_InterpDeleteProc *delProc;
-    void *data;
-} AssocDataValue;
-
-static void JimAssocDataHashTableValueDestructor(void *privdata, void *data)
-{
-    AssocDataValue *assocPtr = (AssocDataValue *) data;
-
-    if (assocPtr->delProc != NULL)
-        assocPtr->delProc((Jim_Interp *)privdata, assocPtr->data);
-    Jim_Free(data);
-}
-
-static const Jim_HashTableType JimAssocDataHashTableType = {
-    JimStringCopyHTHashFunction,
-    JimStringCopyHTDup,
-    NULL,
-    JimStringCopyHTKeyCompare,
-    JimStringCopyHTKeyDestructor,
-    JimAssocDataHashTableValueDestructor
-};
-
-void Jim_InitStack(Jim_Stack *stack)
-{
-    stack->len = 0;
-    stack->maxlen = 0;
-    stack->vector = NULL;
-}
-
-void Jim_FreeStack(Jim_Stack *stack)
-{
-    Jim_Free(stack->vector);
-}
-
-int Jim_StackLen(Jim_Stack *stack)
-{
-    return stack->len;
-}
-
-void Jim_StackPush(Jim_Stack *stack, void *element)
-{
-    int neededLen = stack->len + 1;
-
-    if (neededLen > stack->maxlen) {
-        stack->maxlen = neededLen < 20 ? 20 : neededLen * 2;
-        stack->vector = Jim_Realloc(stack->vector, sizeof(void *) * stack->maxlen);
-    }
-    stack->vector[stack->len] = element;
-    stack->len++;
-}
-
-void *Jim_StackPop(Jim_Stack *stack)
-{
-    if (stack->len == 0)
-        return NULL;
-    stack->len--;
-    return stack->vector[stack->len];
-}
-
-void *Jim_StackPeek(Jim_Stack *stack)
-{
-    if (stack->len == 0)
-        return NULL;
-    return stack->vector[stack->len - 1];
-}
-
-void Jim_FreeStackElements(Jim_Stack *stack, void (*freeFunc) (void *ptr))
-{
-    int i;
-
-    for (i = 0; i < stack->len; i++)
-        freeFunc(stack->vector[i]);
-}
-
-
-
-#define JIM_TT_NONE    0
-#define JIM_TT_STR     1
-#define JIM_TT_ESC     2
-#define JIM_TT_VAR     3
-#define JIM_TT_DICTSUGAR   4
-#define JIM_TT_CMD     5
-
-#define JIM_TT_SEP     6
-#define JIM_TT_EOL     7
-#define JIM_TT_EOF     8
-
-#define JIM_TT_LINE    9
-#define JIM_TT_WORD   10
-
-
-#define JIM_TT_SUBEXPR_START  11
-#define JIM_TT_SUBEXPR_END    12
-#define JIM_TT_SUBEXPR_COMMA  13
-#define JIM_TT_EXPR_INT       14
-#define JIM_TT_EXPR_DOUBLE    15
-#define JIM_TT_EXPR_BOOLEAN   16
-
-#define JIM_TT_EXPRSUGAR      17
-
-
-#define JIM_TT_EXPR_OP        20
-
-#define TOKEN_IS_SEP(type) (type >= JIM_TT_SEP && type <= JIM_TT_EOF)
-
-#define TOKEN_IS_EXPR_START(type) (type == JIM_TT_NONE || type == JIM_TT_SUBEXPR_START || type == JIM_TT_SUBEXPR_COMMA)
-
-#define TOKEN_IS_EXPR_OP(type) (type >= JIM_TT_EXPR_OP)
-
-struct JimParseMissing {
-    int ch;
-    int line;
-};
-
-struct JimParserCtx
-{
-    const char *p;
-    int len;
-    int linenr;
-    const char *tstart;
-    const char *tend;
-    int tline;
-    int tt;
-    int eof;
-    int inquote;
-    int comment;
-    struct JimParseMissing missing;
-    const char *errmsg;
-};
-
-static int JimParseScript(struct JimParserCtx *pc);
-static int JimParseSep(struct JimParserCtx *pc);
-static int JimParseEol(struct JimParserCtx *pc);
-static int JimParseCmd(struct JimParserCtx *pc);
-static int JimParseQuote(struct JimParserCtx *pc);
-static int JimParseVar(struct JimParserCtx *pc);
-static int JimParseBrace(struct JimParserCtx *pc);
-static int JimParseStr(struct JimParserCtx *pc);
-static int JimParseComment(struct JimParserCtx *pc);
-static void JimParseSubCmd(struct JimParserCtx *pc);
-static int JimParseSubQuote(struct JimParserCtx *pc);
-static Jim_Obj *JimParserGetTokenObj(Jim_Interp *interp, struct JimParserCtx *pc);
-
-static void JimParserInit(struct JimParserCtx *pc, const char *prg, int len, int linenr)
-{
-    pc->p = prg;
-    pc->len = len;
-    pc->tstart = NULL;
-    pc->tend = NULL;
-    pc->tline = 0;
-    pc->tt = JIM_TT_NONE;
-    pc->eof = 0;
-    pc->inquote = 0;
-    pc->linenr = linenr;
-    pc->comment = 1;
-    pc->missing.ch = ' ';
-    pc->missing.line = linenr;
-}
-
-static int JimParseScript(struct JimParserCtx *pc)
-{
-    while (1) {
-        if (!pc->len) {
-            pc->tstart = pc->p;
-            pc->tend = pc->p - 1;
-            pc->tline = pc->linenr;
-            pc->tt = JIM_TT_EOL;
-            if (pc->inquote) {
-                pc->missing.ch = '"';
-            }
-            pc->eof = 1;
-            return JIM_OK;
-        }
-        switch (*(pc->p)) {
-            case '\\':
-                if (*(pc->p + 1) == '\n' && !pc->inquote) {
-                    return JimParseSep(pc);
-                }
-                pc->comment = 0;
-                return JimParseStr(pc);
-            case ' ':
-            case '\t':
-            case '\r':
-            case '\f':
-                if (!pc->inquote)
-                    return JimParseSep(pc);
-                pc->comment = 0;
-                return JimParseStr(pc);
-            case '\n':
-            case ';':
-                pc->comment = 1;
-                if (!pc->inquote)
-                    return JimParseEol(pc);
-                return JimParseStr(pc);
-            case '[':
-                pc->comment = 0;
-                return JimParseCmd(pc);
-            case '$':
-                pc->comment = 0;
-                if (JimParseVar(pc) == JIM_ERR) {
-
-                    pc->tstart = pc->tend = pc->p++;
-                    pc->len--;
-                    pc->tt = JIM_TT_ESC;
-                }
-                return JIM_OK;
-            case '#':
-                if (pc->comment) {
-                    JimParseComment(pc);
-                    continue;
-                }
-                return JimParseStr(pc);
-            default:
-                pc->comment = 0;
-                return JimParseStr(pc);
-        }
-        return JIM_OK;
-    }
-}
-
-static int JimParseSep(struct JimParserCtx *pc)
-{
-    pc->tstart = pc->p;
-    pc->tline = pc->linenr;
-    while (isspace(UCHAR(*pc->p)) || (*pc->p == '\\' && *(pc->p + 1) == '\n')) {
-        if (*pc->p == '\n') {
-            break;
-        }
-        if (*pc->p == '\\') {
-            pc->p++;
-            pc->len--;
-            pc->linenr++;
-        }
-        pc->p++;
-        pc->len--;
-    }
-    pc->tend = pc->p - 1;
-    pc->tt = JIM_TT_SEP;
-    return JIM_OK;
-}
-
-static int JimParseEol(struct JimParserCtx *pc)
-{
-    pc->tstart = pc->p;
-    pc->tline = pc->linenr;
-    while (isspace(UCHAR(*pc->p)) || *pc->p == ';') {
-        if (*pc->p == '\n')
-            pc->linenr++;
-        pc->p++;
-        pc->len--;
-    }
-    pc->tend = pc->p - 1;
-    pc->tt = JIM_TT_EOL;
-    return JIM_OK;
-}
-
-
-static void JimParseSubBrace(struct JimParserCtx *pc)
-{
-    int level = 1;
-
-
-    pc->p++;
-    pc->len--;
-    while (pc->len) {
-        switch (*pc->p) {
-            case '\\':
-                if (pc->len > 1) {
-                    if (*++pc->p == '\n') {
-                        pc->linenr++;
-                    }
-                    pc->len--;
-                }
-                break;
-
-            case '{':
-                level++;
-                break;
-
-            case '}':
-                if (--level == 0) {
-                    pc->tend = pc->p - 1;
-                    pc->p++;
-                    pc->len--;
-                    return;
-                }
-                break;
-
-            case '\n':
-                pc->linenr++;
-                break;
-        }
-        pc->p++;
-        pc->len--;
-    }
-    pc->missing.ch = '{';
-    pc->missing.line = pc->tline;
-    pc->tend = pc->p - 1;
-}
-
-static int JimParseSubQuote(struct JimParserCtx *pc)
-{
-    int tt = JIM_TT_STR;
-    int line = pc->tline;
-
-
-    pc->p++;
-    pc->len--;
-    while (pc->len) {
-        switch (*pc->p) {
-            case '\\':
-                if (pc->len > 1) {
-                    if (*++pc->p == '\n') {
-                        pc->linenr++;
-                    }
-                    pc->len--;
-                    tt = JIM_TT_ESC;
-                }
-                break;
-
-            case '"':
-                pc->tend = pc->p - 1;
-                pc->p++;
-                pc->len--;
-                return tt;
-
-            case '[':
-                JimParseSubCmd(pc);
-                tt = JIM_TT_ESC;
-                continue;
-
-            case '\n':
-                pc->linenr++;
-                break;
-
-            case '$':
-                tt = JIM_TT_ESC;
-                break;
-        }
-        pc->p++;
-        pc->len--;
-    }
-    pc->missing.ch = '"';
-    pc->missing.line = line;
-    pc->tend = pc->p - 1;
-    return tt;
-}
-
-static void JimParseSubCmd(struct JimParserCtx *pc)
-{
-    int level = 1;
-    int startofword = 1;
-    int line = pc->tline;
-
-
-    pc->p++;
-    pc->len--;
-    while (pc->len) {
-        switch (*pc->p) {
-            case '\\':
-                if (pc->len > 1) {
-                    if (*++pc->p == '\n') {
-                        pc->linenr++;
-                    }
-                    pc->len--;
-                }
-                break;
-
-            case '[':
-                level++;
-                break;
-
-            case ']':
-                if (--level == 0) {
-                    pc->tend = pc->p - 1;
-                    pc->p++;
-                    pc->len--;
-                    return;
-                }
-                break;
-
-            case '"':
-                if (startofword) {
-                    JimParseSubQuote(pc);
-                    if (pc->missing.ch == '"') {
-                        return;
-                    }
-                    continue;
-                }
-                break;
-
-            case '{':
-                JimParseSubBrace(pc);
-                startofword = 0;
-                continue;
-
-            case '\n':
-                pc->linenr++;
-                break;
-        }
-        startofword = isspace(UCHAR(*pc->p));
-        pc->p++;
-        pc->len--;
-    }
-    pc->missing.ch = '[';
-    pc->missing.line = line;
-    pc->tend = pc->p - 1;
-}
-
-static int JimParseBrace(struct JimParserCtx *pc)
-{
-    pc->tstart = pc->p + 1;
-    pc->tline = pc->linenr;
-    pc->tt = JIM_TT_STR;
-    JimParseSubBrace(pc);
-    return JIM_OK;
-}
-
-static int JimParseCmd(struct JimParserCtx *pc)
-{
-    pc->tstart = pc->p + 1;
-    pc->tline = pc->linenr;
-    pc->tt = JIM_TT_CMD;
-    JimParseSubCmd(pc);
-    return JIM_OK;
-}
-
-static int JimParseQuote(struct JimParserCtx *pc)
-{
-    pc->tstart = pc->p + 1;
-    pc->tline = pc->linenr;
-    pc->tt = JimParseSubQuote(pc);
-    return JIM_OK;
-}
-
-static int JimParseVar(struct JimParserCtx *pc)
-{
-
-    pc->p++;
-    pc->len--;
-
-#ifdef EXPRSUGAR_BRACKET
-    if (*pc->p == '[') {
-
-        JimParseCmd(pc);
-        pc->tt = JIM_TT_EXPRSUGAR;
-        return JIM_OK;
-    }
-#endif
-
-    pc->tstart = pc->p;
-    pc->tt = JIM_TT_VAR;
-    pc->tline = pc->linenr;
-
-    if (*pc->p == '{') {
-        pc->tstart = ++pc->p;
-        pc->len--;
-
-        while (pc->len && *pc->p != '}') {
-            if (*pc->p == '\n') {
-                pc->linenr++;
-            }
-            pc->p++;
-            pc->len--;
-        }
-        pc->tend = pc->p - 1;
-        if (pc->len) {
-            pc->p++;
-            pc->len--;
-        }
-    }
-    else {
-        while (1) {
-
-            if (pc->p[0] == ':' && pc->p[1] == ':') {
-                while (*pc->p == ':') {
-                    pc->p++;
-                    pc->len--;
-                }
-                continue;
-            }
-            if (isalnum(UCHAR(*pc->p)) || *pc->p == '_' || UCHAR(*pc->p) >= 0x80) {
-                pc->p++;
-                pc->len--;
-                continue;
-            }
-            break;
-        }
-
-        if (*pc->p == '(') {
-            int count = 1;
-            const char *paren = NULL;
-
-            pc->tt = JIM_TT_DICTSUGAR;
-
-            while (count && pc->len) {
-                pc->p++;
-                pc->len--;
-                if (*pc->p == '\\' && pc->len >= 1) {
-                    pc->p++;
-                    pc->len--;
-                }
-                else if (*pc->p == '(') {
-                    count++;
-                }
-                else if (*pc->p == ')') {
-                    paren = pc->p;
-                    count--;
-                }
-            }
-            if (count == 0) {
-                pc->p++;
-                pc->len--;
-            }
-            else if (paren) {
-
-                paren++;
-                pc->len += (pc->p - paren);
-                pc->p = paren;
-            }
-#ifndef EXPRSUGAR_BRACKET
-            if (*pc->tstart == '(') {
-                pc->tt = JIM_TT_EXPRSUGAR;
-            }
-#endif
-        }
-        pc->tend = pc->p - 1;
-    }
-    if (pc->tstart == pc->p) {
-        pc->p--;
-        pc->len++;
-        return JIM_ERR;
-    }
-    return JIM_OK;
-}
-
-static int JimParseStr(struct JimParserCtx *pc)
-{
-    if (pc->tt == JIM_TT_SEP || pc->tt == JIM_TT_EOL ||
-        pc->tt == JIM_TT_NONE || pc->tt == JIM_TT_STR) {
-
-        if (*pc->p == '{') {
-            return JimParseBrace(pc);
-        }
-        if (*pc->p == '"') {
-            pc->inquote = 1;
-            pc->p++;
-            pc->len--;
-
-            pc->missing.line = pc->tline;
-        }
-    }
-    pc->tstart = pc->p;
-    pc->tline = pc->linenr;
-    while (1) {
-        if (pc->len == 0) {
-            if (pc->inquote) {
-                pc->missing.ch = '"';
-            }
-            pc->tend = pc->p - 1;
-            pc->tt = JIM_TT_ESC;
-            return JIM_OK;
-        }
-        switch (*pc->p) {
-            case '\\':
-                if (!pc->inquote && *(pc->p + 1) == '\n') {
-                    pc->tend = pc->p - 1;
-                    pc->tt = JIM_TT_ESC;
-                    return JIM_OK;
-                }
-                if (pc->len >= 2) {
-                    if (*(pc->p + 1) == '\n') {
-                        pc->linenr++;
-                    }
-                    pc->p++;
-                    pc->len--;
-                }
-                else if (pc->len == 1) {
-
-                    pc->missing.ch = '\\';
-                }
-                break;
-            case '(':
-
-                if (pc->len > 1 && pc->p[1] != '$') {
-                    break;
-                }
-
-            case ')':
-
-                if (*pc->p == '(' || pc->tt == JIM_TT_VAR) {
-                    if (pc->p == pc->tstart) {
-
-                        pc->p++;
-                        pc->len--;
-                    }
-                    pc->tend = pc->p - 1;
-                    pc->tt = JIM_TT_ESC;
-                    return JIM_OK;
-                }
-                break;
-
-            case '$':
-            case '[':
-                pc->tend = pc->p - 1;
-                pc->tt = JIM_TT_ESC;
-                return JIM_OK;
-            case ' ':
-            case '\t':
-            case '\n':
-            case '\r':
-            case '\f':
-            case ';':
-                if (!pc->inquote) {
-                    pc->tend = pc->p - 1;
-                    pc->tt = JIM_TT_ESC;
-                    return JIM_OK;
-                }
-                else if (*pc->p == '\n') {
-                    pc->linenr++;
-                }
-                break;
-            case '"':
-                if (pc->inquote) {
-                    pc->tend = pc->p - 1;
-                    pc->tt = JIM_TT_ESC;
-                    pc->p++;
-                    pc->len--;
-                    pc->inquote = 0;
-                    return JIM_OK;
-                }
-                break;
-        }
-        pc->p++;
-        pc->len--;
-    }
-    return JIM_OK;
-}
-
-static int JimParseComment(struct JimParserCtx *pc)
-{
-    while (*pc->p) {
-        if (*pc->p == '\\') {
-            pc->p++;
-            pc->len--;
-            if (pc->len == 0) {
-                pc->missing.ch = '\\';
-                return JIM_OK;
-            }
-            if (*pc->p == '\n') {
-                pc->linenr++;
-            }
-        }
-        else if (*pc->p == '\n') {
-            pc->p++;
-            pc->len--;
-            pc->linenr++;
-            break;
-        }
-        pc->p++;
-        pc->len--;
-    }
-    return JIM_OK;
-}
-
-
-static int xdigitval(int c)
-{
-    if (c >= '0' && c <= '9')
-        return c - '0';
-    if (c >= 'a' && c <= 'f')
-        return c - 'a' + 10;
-    if (c >= 'A' && c <= 'F')
-        return c - 'A' + 10;
-    return -1;
-}
-
-static int odigitval(int c)
-{
-    if (c >= '0' && c <= '7')
-        return c - '0';
-    return -1;
-}
-
-static int JimEscape(char *dest, const char *s, int slen)
-{
-    char *p = dest;
-    int i, len;
-
-    for (i = 0; i < slen; i++) {
-        switch (s[i]) {
-            case '\\':
-                switch (s[i + 1]) {
-                    case 'a':
-                        *p++ = 0x7;
-                        i++;
-                        break;
-                    case 'b':
-                        *p++ = 0x8;
-                        i++;
-                        break;
-                    case 'f':
-                        *p++ = 0xc;
-                        i++;
-                        break;
-                    case 'n':
-                        *p++ = 0xa;
-                        i++;
-                        break;
-                    case 'r':
-                        *p++ = 0xd;
-                        i++;
-                        break;
-                    case 't':
-                        *p++ = 0x9;
-                        i++;
-                        break;
-                    case 'u':
-                    case 'U':
-                    case 'x':
-                        {
-                            unsigned val = 0;
-                            int k;
-                            int maxchars = 2;
-
-                            i++;
-
-                            if (s[i] == 'U') {
-                                maxchars = 8;
-                            }
-                            else if (s[i] == 'u') {
-                                if (s[i + 1] == '{') {
-                                    maxchars = 6;
-                                    i++;
-                                }
-                                else {
-                                    maxchars = 4;
-                                }
-                            }
-
-                            for (k = 0; k < maxchars; k++) {
-                                int c = xdigitval(s[i + k + 1]);
-                                if (c == -1) {
-                                    break;
-                                }
-                                val = (val << 4) | c;
-                            }
-
-                            if (s[i] == '{') {
-                                if (k == 0 || val > 0x1fffff || s[i + k + 1] != '}') {
-
-                                    i--;
-                                    k = 0;
-                                }
-                                else {
-
-                                    k++;
-                                }
-                            }
-                            if (k) {
-
-                                if (s[i] == 'x') {
-                                    *p++ = val;
-                                }
-                                else {
-                                    p += utf8_fromunicode(p, val);
-                                }
-                                i += k;
-                                break;
-                            }
-
-                            *p++ = s[i];
-                        }
-                        break;
-                    case 'v':
-                        *p++ = 0xb;
-                        i++;
-                        break;
-                    case '\0':
-                        *p++ = '\\';
-                        i++;
-                        break;
-                    case '\n':
-
-                        *p++ = ' ';
-                        do {
-                            i++;
-                        } while (s[i + 1] == ' ' || s[i + 1] == '\t');
-                        break;
-                    case '0':
-                    case '1':
-                    case '2':
-                    case '3':
-                    case '4':
-                    case '5':
-                    case '6':
-                    case '7':
-
-                        {
-                            int val = 0;
-                            int c = odigitval(s[i + 1]);
-
-                            val = c;
-                            c = odigitval(s[i + 2]);
-                            if (c == -1) {
-                                *p++ = val;
-                                i++;
-                                break;
-                            }
-                            val = (val * 8) + c;
-                            c = odigitval(s[i + 3]);
-                            if (c == -1) {
-                                *p++ = val;
-                                i += 2;
-                                break;
-                            }
-                            val = (val * 8) + c;
-                            *p++ = val;
-                            i += 3;
-                        }
-                        break;
-                    default:
-                        *p++ = s[i + 1];
-                        i++;
-                        break;
-                }
-                break;
-            default:
-                *p++ = s[i];
-                break;
-        }
-    }
-    len = p - dest;
-    *p = '\0';
-    return len;
-}
-
-static Jim_Obj *JimParserGetTokenObj(Jim_Interp *interp, struct JimParserCtx *pc)
-{
-    const char *start, *end;
-    char *token;
-    int len;
-
-    start = pc->tstart;
-    end = pc->tend;
-    len = (end - start) + 1;
-    if (len < 0) {
-        len = 0;
-    }
-    token = Jim_Alloc(len + 1);
-    if (pc->tt != JIM_TT_ESC) {
-
-        memcpy(token, start, len);
-        token[len] = '\0';
-    }
-    else {
-
-        len = JimEscape(token, start, len);
-    }
-
-    return Jim_NewStringObjNoAlloc(interp, token, len);
-}
-
-static int JimParseListSep(struct JimParserCtx *pc);
-static int JimParseListStr(struct JimParserCtx *pc);
-static int JimParseListQuote(struct JimParserCtx *pc);
-
-static int JimParseList(struct JimParserCtx *pc)
-{
-    if (isspace(UCHAR(*pc->p))) {
-        return JimParseListSep(pc);
-    }
-    switch (*pc->p) {
-        case '"':
-            return JimParseListQuote(pc);
-
-        case '{':
-            return JimParseBrace(pc);
-
-        default:
-            if (pc->len) {
-                return JimParseListStr(pc);
-            }
-            break;
-    }
-
-    pc->tstart = pc->tend = pc->p;
-    pc->tline = pc->linenr;
-    pc->tt = JIM_TT_EOL;
-    pc->eof = 1;
-    return JIM_OK;
-}
-
-static int JimParseListSep(struct JimParserCtx *pc)
-{
-    pc->tstart = pc->p;
-    pc->tline = pc->linenr;
-    while (isspace(UCHAR(*pc->p))) {
-        if (*pc->p == '\n') {
-            pc->linenr++;
-        }
-        pc->p++;
-        pc->len--;
-    }
-    pc->tend = pc->p - 1;
-    pc->tt = JIM_TT_SEP;
-    return JIM_OK;
-}
-
-static int JimParseListQuote(struct JimParserCtx *pc)
-{
-    pc->p++;
-    pc->len--;
-
-    pc->tstart = pc->p;
-    pc->tline = pc->linenr;
-    pc->tt = JIM_TT_STR;
-
-    while (pc->len) {
-        switch (*pc->p) {
-            case '\\':
-                pc->tt = JIM_TT_ESC;
-                if (--pc->len == 0) {
-
-                    pc->tend = pc->p;
-                    return JIM_OK;
-                }
-                pc->p++;
-                break;
-            case '\n':
-                pc->linenr++;
-                break;
-            case '"':
-                pc->tend = pc->p - 1;
-                pc->p++;
-                pc->len--;
-                return JIM_OK;
-        }
-        pc->p++;
-        pc->len--;
-    }
-
-    pc->tend = pc->p - 1;
-    return JIM_OK;
-}
-
-static int JimParseListStr(struct JimParserCtx *pc)
-{
-    pc->tstart = pc->p;
-    pc->tline = pc->linenr;
-    pc->tt = JIM_TT_STR;
-
-    while (pc->len) {
-        if (isspace(UCHAR(*pc->p))) {
-            pc->tend = pc->p - 1;
-            return JIM_OK;
-        }
-        if (*pc->p == '\\') {
-            if (--pc->len == 0) {
-
-                pc->tend = pc->p;
-                return JIM_OK;
-            }
-            pc->tt = JIM_TT_ESC;
-            pc->p++;
-        }
-        pc->p++;
-        pc->len--;
-    }
-    pc->tend = pc->p - 1;
-    return JIM_OK;
-}
-
-
-
-Jim_Obj *Jim_NewObj(Jim_Interp *interp)
-{
-    Jim_Obj *objPtr;
-
-
-    if (interp->freeList != NULL) {
-
-        objPtr = interp->freeList;
-        interp->freeList = objPtr->nextObjPtr;
-    }
-    else {
-
-        objPtr = Jim_Alloc(sizeof(*objPtr));
-    }
-
-    objPtr->refCount = 0;
-
-
-    objPtr->prevObjPtr = NULL;
-    objPtr->nextObjPtr = interp->liveList;
-    if (interp->liveList)
-        interp->liveList->prevObjPtr = objPtr;
-    interp->liveList = objPtr;
-
-    return objPtr;
-}
-
-void Jim_FreeObj(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-
-    JimPanic((objPtr->refCount != 0, "!!!Object %p freed with bad refcount %d, type=%s", objPtr,
-        objPtr->refCount, objPtr->typePtr ? objPtr->typePtr->name : "<none>"));
-
-
-    Jim_FreeIntRep(interp, objPtr);
-
-    if (objPtr->bytes != NULL) {
-        if (objPtr->bytes != JimEmptyStringRep)
-            Jim_Free(objPtr->bytes);
-    }
-
-    if (objPtr->prevObjPtr)
-        objPtr->prevObjPtr->nextObjPtr = objPtr->nextObjPtr;
-    if (objPtr->nextObjPtr)
-        objPtr->nextObjPtr->prevObjPtr = objPtr->prevObjPtr;
-    if (interp->liveList == objPtr)
-        interp->liveList = objPtr->nextObjPtr;
-#ifdef JIM_DISABLE_OBJECT_POOL
-    Jim_Free(objPtr);
-#else
-
-    objPtr->prevObjPtr = NULL;
-    objPtr->nextObjPtr = interp->freeList;
-    if (interp->freeList)
-        interp->freeList->prevObjPtr = objPtr;
-    interp->freeList = objPtr;
-    objPtr->refCount = -1;
-#endif
-}
-
-
-void Jim_InvalidateStringRep(Jim_Obj *objPtr)
-{
-    if (objPtr->bytes != NULL) {
-        if (objPtr->bytes != JimEmptyStringRep)
-            Jim_Free(objPtr->bytes);
-    }
-    objPtr->bytes = NULL;
-}
-
-
-Jim_Obj *Jim_DuplicateObj(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    Jim_Obj *dupPtr;
-
-    dupPtr = Jim_NewObj(interp);
-    if (objPtr->bytes == NULL) {
-
-        dupPtr->bytes = NULL;
-    }
-    else if (objPtr->length == 0) {
-        dupPtr->bytes = JimEmptyStringRep;
-        dupPtr->length = 0;
-        dupPtr->typePtr = NULL;
-        return dupPtr;
-    }
-    else {
-        dupPtr->bytes = Jim_Alloc(objPtr->length + 1);
-        dupPtr->length = objPtr->length;
-
-        memcpy(dupPtr->bytes, objPtr->bytes, objPtr->length + 1);
-    }
-
-
-    dupPtr->typePtr = objPtr->typePtr;
-    if (objPtr->typePtr != NULL) {
-        if (objPtr->typePtr->dupIntRepProc == NULL) {
-            dupPtr->internalRep = objPtr->internalRep;
-        }
-        else {
-
-            objPtr->typePtr->dupIntRepProc(interp, objPtr, dupPtr);
-        }
-    }
-    return dupPtr;
-}
-
-const char *Jim_GetString(Jim_Obj *objPtr, int *lenPtr)
-{
-    if (objPtr->bytes == NULL) {
-
-        JimPanic((objPtr->typePtr->updateStringProc == NULL, "UpdateStringProc called against '%s' type.", objPtr->typePtr->name));
-        objPtr->typePtr->updateStringProc(objPtr);
-    }
-    if (lenPtr)
-        *lenPtr = objPtr->length;
-    return objPtr->bytes;
-}
-
-
-int Jim_Length(Jim_Obj *objPtr)
-{
-    if (objPtr->bytes == NULL) {
-
-        Jim_GetString(objPtr, NULL);
-    }
-    return objPtr->length;
-}
-
-
-const char *Jim_String(Jim_Obj *objPtr)
-{
-    if (objPtr->bytes == NULL) {
-
-        Jim_GetString(objPtr, NULL);
-    }
-    return objPtr->bytes;
-}
-
-static void JimSetStringBytes(Jim_Obj *objPtr, const char *str)
-{
-    objPtr->bytes = Jim_StrDup(str);
-    objPtr->length = strlen(str);
-}
-
-static void FreeDictSubstInternalRep(Jim_Interp *interp, Jim_Obj *objPtr);
-static void DupDictSubstInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
-
-static const Jim_ObjType dictSubstObjType = {
-    "dict-substitution",
-    FreeDictSubstInternalRep,
-    DupDictSubstInternalRep,
-    NULL,
-    JIM_TYPE_NONE,
-};
-
-static void FreeInterpolatedInternalRep(Jim_Interp *interp, Jim_Obj *objPtr);
-static void DupInterpolatedInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
-
-static const Jim_ObjType interpolatedObjType = {
-    "interpolated",
-    FreeInterpolatedInternalRep,
-    DupInterpolatedInternalRep,
-    NULL,
-    JIM_TYPE_NONE,
-};
-
-static void FreeInterpolatedInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    Jim_DecrRefCount(interp, objPtr->internalRep.dictSubstValue.indexObjPtr);
-}
-
-static void DupInterpolatedInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
-{
-
-    dupPtr->internalRep = srcPtr->internalRep;
-
-    Jim_IncrRefCount(dupPtr->internalRep.dictSubstValue.indexObjPtr);
-}
-
-static void DupStringInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
-static int SetStringFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
-
-static const Jim_ObjType stringObjType = {
-    "string",
-    NULL,
-    DupStringInternalRep,
-    NULL,
-    JIM_TYPE_REFERENCES,
-};
-
-static void DupStringInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
-{
-    JIM_NOTUSED(interp);
-
-    dupPtr->internalRep.strValue.maxLength = srcPtr->length;
-    dupPtr->internalRep.strValue.charLength = srcPtr->internalRep.strValue.charLength;
-}
-
-static int SetStringFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    if (objPtr->typePtr != &stringObjType) {
-
-        if (objPtr->bytes == NULL) {
-
-            JimPanic((objPtr->typePtr->updateStringProc == NULL, "UpdateStringProc called against '%s' type.", objPtr->typePtr->name));
-            objPtr->typePtr->updateStringProc(objPtr);
-        }
-
-        Jim_FreeIntRep(interp, objPtr);
-
-        objPtr->typePtr = &stringObjType;
-        objPtr->internalRep.strValue.maxLength = objPtr->length;
-
-        objPtr->internalRep.strValue.charLength = -1;
-    }
-    return JIM_OK;
-}
-
-int Jim_Utf8Length(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-#ifdef JIM_UTF8
-    SetStringFromAny(interp, objPtr);
-
-    if (objPtr->internalRep.strValue.charLength < 0) {
-        objPtr->internalRep.strValue.charLength = utf8_strlen(objPtr->bytes, objPtr->length);
-    }
-    return objPtr->internalRep.strValue.charLength;
-#else
-    return Jim_Length(objPtr);
-#endif
-}
-
-
-Jim_Obj *Jim_NewStringObj(Jim_Interp *interp, const char *s, int len)
-{
-    Jim_Obj *objPtr = Jim_NewObj(interp);
-
-
-    if (len == -1)
-        len = strlen(s);
-
-    if (len == 0) {
-        objPtr->bytes = JimEmptyStringRep;
-    }
-    else {
-        objPtr->bytes = Jim_StrDupLen(s, len);
-    }
-    objPtr->length = len;
-
-
-    objPtr->typePtr = NULL;
-    return objPtr;
-}
-
-
-Jim_Obj *Jim_NewStringObjUtf8(Jim_Interp *interp, const char *s, int charlen)
-{
-#ifdef JIM_UTF8
-
-    int bytelen = utf8_index(s, charlen);
-
-    Jim_Obj *objPtr = Jim_NewStringObj(interp, s, bytelen);
-
-
-    objPtr->typePtr = &stringObjType;
-    objPtr->internalRep.strValue.maxLength = bytelen;
-    objPtr->internalRep.strValue.charLength = charlen;
-
-    return objPtr;
-#else
-    return Jim_NewStringObj(interp, s, charlen);
-#endif
-}
-
-Jim_Obj *Jim_NewStringObjNoAlloc(Jim_Interp *interp, char *s, int len)
-{
-    Jim_Obj *objPtr = Jim_NewObj(interp);
-
-    objPtr->bytes = s;
-    objPtr->length = (len == -1) ? strlen(s) : len;
-    objPtr->typePtr = NULL;
-    return objPtr;
-}
-
-static void StringAppendString(Jim_Obj *objPtr, const char *str, int len)
-{
-    int needlen;
-
-    if (len == -1)
-        len = strlen(str);
-    needlen = objPtr->length + len;
-    if (objPtr->internalRep.strValue.maxLength < needlen ||
-        objPtr->internalRep.strValue.maxLength == 0) {
-        needlen *= 2;
-
-        if (needlen < 7) {
-            needlen = 7;
-        }
-        if (objPtr->bytes == JimEmptyStringRep) {
-            objPtr->bytes = Jim_Alloc(needlen + 1);
-        }
-        else {
-            objPtr->bytes = Jim_Realloc(objPtr->bytes, needlen + 1);
-        }
-        objPtr->internalRep.strValue.maxLength = needlen;
-    }
-    memcpy(objPtr->bytes + objPtr->length, str, len);
-    objPtr->bytes[objPtr->length + len] = '\0';
-
-    if (objPtr->internalRep.strValue.charLength >= 0) {
-
-        objPtr->internalRep.strValue.charLength += utf8_strlen(objPtr->bytes + objPtr->length, len);
-    }
-    objPtr->length += len;
-}
-
-void Jim_AppendString(Jim_Interp *interp, Jim_Obj *objPtr, const char *str, int len)
-{
-    JimPanic((Jim_IsShared(objPtr), "Jim_AppendString called with shared object"));
-    SetStringFromAny(interp, objPtr);
-    StringAppendString(objPtr, str, len);
-}
-
-void Jim_AppendObj(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *appendObjPtr)
-{
-    int len;
-    const char *str = Jim_GetString(appendObjPtr, &len);
-    Jim_AppendString(interp, objPtr, str, len);
-}
-
-void Jim_AppendStrings(Jim_Interp *interp, Jim_Obj *objPtr, ...)
-{
-    va_list ap;
-
-    SetStringFromAny(interp, objPtr);
-    va_start(ap, objPtr);
-    while (1) {
-        const char *s = va_arg(ap, const char *);
-
-        if (s == NULL)
-            break;
-        Jim_AppendString(interp, objPtr, s, -1);
-    }
-    va_end(ap);
-}
-
-int Jim_StringEqObj(Jim_Obj *aObjPtr, Jim_Obj *bObjPtr)
-{
-    if (aObjPtr == bObjPtr) {
-        return 1;
-    }
-    else {
-        int Alen, Blen;
-        const char *sA = Jim_GetString(aObjPtr, &Alen);
-        const char *sB = Jim_GetString(bObjPtr, &Blen);
-
-        return Alen == Blen && memcmp(sA, sB, Alen) == 0;
-    }
-}
-
-int Jim_StringMatchObj(Jim_Interp *interp, Jim_Obj *patternObjPtr, Jim_Obj *objPtr, int nocase)
-{
-    int plen, slen;
-    const char *pattern = Jim_GetString(patternObjPtr, &plen);
-    const char *string = Jim_GetString(objPtr, &slen);
-    return JimGlobMatch(pattern, plen, string, slen, nocase);
-}
-
-int Jim_StringCompareObj(Jim_Interp *interp, Jim_Obj *firstObjPtr, Jim_Obj *secondObjPtr, int nocase)
-{
-    const char *s1 = Jim_String(firstObjPtr);
-    int l1 = Jim_Utf8Length(interp, firstObjPtr);
-    const char *s2 = Jim_String(secondObjPtr);
-    int l2 = Jim_Utf8Length(interp, secondObjPtr);
-    return JimStringCompareUtf8(s1, l1, s2, l2, nocase);
-}
-
-static int JimRelToAbsIndex(int len, int idx)
-{
-    if (idx < 0 && idx > -INT_MAX)
-        return len + idx;
-    return idx;
-}
-
-static void JimRelToAbsRange(int len, int *firstPtr, int *lastPtr, int *rangeLenPtr)
-{
-    int rangeLen;
-
-    if (*firstPtr > *lastPtr) {
-        rangeLen = 0;
-    }
-    else {
-        rangeLen = *lastPtr - *firstPtr + 1;
-        if (rangeLen) {
-            if (*firstPtr < 0) {
-                rangeLen += *firstPtr;
-                *firstPtr = 0;
-            }
-            if (*lastPtr >= len) {
-                rangeLen -= (*lastPtr - (len - 1));
-                *lastPtr = len - 1;
-            }
-        }
-    }
-    if (rangeLen < 0)
-        rangeLen = 0;
-
-    *rangeLenPtr = rangeLen;
-}
-
-static int JimStringGetRange(Jim_Interp *interp, Jim_Obj *firstObjPtr, Jim_Obj *lastObjPtr,
-    int len, int *first, int *last, int *range)
-{
-    if (Jim_GetIndex(interp, firstObjPtr, first) != JIM_OK) {
-        return JIM_ERR;
-    }
-    if (Jim_GetIndex(interp, lastObjPtr, last) != JIM_OK) {
-        return JIM_ERR;
-    }
-    *first = JimRelToAbsIndex(len, *first);
-    *last = JimRelToAbsIndex(len, *last);
-    JimRelToAbsRange(len, first, last, range);
-    return JIM_OK;
-}
-
-Jim_Obj *Jim_StringByteRangeObj(Jim_Interp *interp,
-    Jim_Obj *strObjPtr, Jim_Obj *firstObjPtr, Jim_Obj *lastObjPtr)
-{
-    int first, last;
-    const char *str;
-    int rangeLen;
-    int bytelen;
-
-    str = Jim_GetString(strObjPtr, &bytelen);
-
-    if (JimStringGetRange(interp, firstObjPtr, lastObjPtr, bytelen, &first, &last, &rangeLen) != JIM_OK) {
-        return NULL;
-    }
-
-    if (first == 0 && rangeLen == bytelen) {
-        return strObjPtr;
-    }
-    return Jim_NewStringObj(interp, str + first, rangeLen);
-}
-
-Jim_Obj *Jim_StringRangeObj(Jim_Interp *interp,
-    Jim_Obj *strObjPtr, Jim_Obj *firstObjPtr, Jim_Obj *lastObjPtr)
-{
-#ifdef JIM_UTF8
-    int first, last;
-    const char *str;
-    int len, rangeLen;
-    int bytelen;
-
-    str = Jim_GetString(strObjPtr, &bytelen);
-    len = Jim_Utf8Length(interp, strObjPtr);
-
-    if (JimStringGetRange(interp, firstObjPtr, lastObjPtr, len, &first, &last, &rangeLen) != JIM_OK) {
-        return NULL;
-    }
-
-    if (first == 0 && rangeLen == len) {
-        return strObjPtr;
-    }
-    if (len == bytelen) {
-
-        return Jim_NewStringObj(interp, str + first, rangeLen);
-    }
-    return Jim_NewStringObjUtf8(interp, str + utf8_index(str, first), rangeLen);
-#else
-    return Jim_StringByteRangeObj(interp, strObjPtr, firstObjPtr, lastObjPtr);
-#endif
-}
-
-Jim_Obj *JimStringReplaceObj(Jim_Interp *interp,
-    Jim_Obj *strObjPtr, Jim_Obj *firstObjPtr, Jim_Obj *lastObjPtr, Jim_Obj *newStrObj)
-{
-    int first, last;
-    const char *str;
-    int len, rangeLen;
-    Jim_Obj *objPtr;
-
-    len = Jim_Utf8Length(interp, strObjPtr);
-
-    if (JimStringGetRange(interp, firstObjPtr, lastObjPtr, len, &first, &last, &rangeLen) != JIM_OK) {
-        return NULL;
-    }
-
-    if (last < first) {
-        return strObjPtr;
-    }
-
-    str = Jim_String(strObjPtr);
-
-
-    objPtr = Jim_NewStringObjUtf8(interp, str, first);
-
-
-    if (newStrObj) {
-        Jim_AppendObj(interp, objPtr, newStrObj);
-    }
-
-
-    Jim_AppendString(interp, objPtr, str + utf8_index(str, last + 1), len - last - 1);
-
-    return objPtr;
-}
-
-static void JimStrCopyUpperLower(char *dest, const char *str, int uc)
-{
-    while (*str) {
-        int c;
-        str += utf8_tounicode(str, &c);
-        dest += utf8_getchars(dest, uc ? utf8_upper(c) : utf8_lower(c));
-    }
-    *dest = 0;
-}
-
-static Jim_Obj *JimStringToLower(Jim_Interp *interp, Jim_Obj *strObjPtr)
-{
-    char *buf;
-    int len;
-    const char *str;
-
-    str = Jim_GetString(strObjPtr, &len);
-
-#ifdef JIM_UTF8
-    len *= 2;
-#endif
-    buf = Jim_Alloc(len + 1);
-    JimStrCopyUpperLower(buf, str, 0);
-    return Jim_NewStringObjNoAlloc(interp, buf, -1);
-}
-
-static Jim_Obj *JimStringToUpper(Jim_Interp *interp, Jim_Obj *strObjPtr)
-{
-    char *buf;
-    const char *str;
-    int len;
-
-    str = Jim_GetString(strObjPtr, &len);
-
-#ifdef JIM_UTF8
-    len *= 2;
-#endif
-    buf = Jim_Alloc(len + 1);
-    JimStrCopyUpperLower(buf, str, 1);
-    return Jim_NewStringObjNoAlloc(interp, buf, -1);
-}
-
-static Jim_Obj *JimStringToTitle(Jim_Interp *interp, Jim_Obj *strObjPtr)
-{
-    char *buf, *p;
-    int len;
-    int c;
-    const char *str;
-
-    str = Jim_GetString(strObjPtr, &len);
-
-#ifdef JIM_UTF8
-    len *= 2;
-#endif
-    buf = p = Jim_Alloc(len + 1);
-
-    str += utf8_tounicode(str, &c);
-    p += utf8_getchars(p, utf8_title(c));
-
-    JimStrCopyUpperLower(p, str, 0);
-
-    return Jim_NewStringObjNoAlloc(interp, buf, -1);
-}
-
-static const char *utf8_memchr(const char *str, int len, int c)
-{
-#ifdef JIM_UTF8
-    while (len) {
-        int sc;
-        int n = utf8_tounicode(str, &sc);
-        if (sc == c) {
-            return str;
-        }
-        str += n;
-        len -= n;
-    }
-    return NULL;
-#else
-    return memchr(str, c, len);
-#endif
-}
-
-static const char *JimFindTrimLeft(const char *str, int len, const char *trimchars, int trimlen)
-{
-    while (len) {
-        int c;
-        int n = utf8_tounicode(str, &c);
-
-        if (utf8_memchr(trimchars, trimlen, c) == NULL) {
-
-            break;
-        }
-        str += n;
-        len -= n;
-    }
-    return str;
-}
-
-static const char *JimFindTrimRight(const char *str, int len, const char *trimchars, int trimlen)
-{
-    str += len;
-
-    while (len) {
-        int c;
-        int n = utf8_prev_len(str, len);
-
-        len -= n;
-        str -= n;
-
-        n = utf8_tounicode(str, &c);
-
-        if (utf8_memchr(trimchars, trimlen, c) == NULL) {
-            return str + n;
-        }
-    }
-
-    return NULL;
-}
-
-static const char default_trim_chars[] = " \t\n\r";
-
-static int default_trim_chars_len = sizeof(default_trim_chars);
-
-static Jim_Obj *JimStringTrimLeft(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *trimcharsObjPtr)
-{
-    int len;
-    const char *str = Jim_GetString(strObjPtr, &len);
-    const char *trimchars = default_trim_chars;
-    int trimcharslen = default_trim_chars_len;
-    const char *newstr;
-
-    if (trimcharsObjPtr) {
-        trimchars = Jim_GetString(trimcharsObjPtr, &trimcharslen);
-    }
-
-    newstr = JimFindTrimLeft(str, len, trimchars, trimcharslen);
-    if (newstr == str) {
-        return strObjPtr;
-    }
-
-    return Jim_NewStringObj(interp, newstr, len - (newstr - str));
-}
-
-static Jim_Obj *JimStringTrimRight(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *trimcharsObjPtr)
-{
-    int len;
-    const char *trimchars = default_trim_chars;
-    int trimcharslen = default_trim_chars_len;
-    const char *nontrim;
-
-    if (trimcharsObjPtr) {
-        trimchars = Jim_GetString(trimcharsObjPtr, &trimcharslen);
-    }
-
-    SetStringFromAny(interp, strObjPtr);
-
-    len = Jim_Length(strObjPtr);
-    nontrim = JimFindTrimRight(strObjPtr->bytes, len, trimchars, trimcharslen);
-
-    if (nontrim == NULL) {
-
-        return Jim_NewEmptyStringObj(interp);
-    }
-    if (nontrim == strObjPtr->bytes + len) {
-
-        return strObjPtr;
-    }
-
-    if (Jim_IsShared(strObjPtr)) {
-        strObjPtr = Jim_NewStringObj(interp, strObjPtr->bytes, (nontrim - strObjPtr->bytes));
-    }
-    else {
-
-        strObjPtr->bytes[nontrim - strObjPtr->bytes] = 0;
-        strObjPtr->length = (nontrim - strObjPtr->bytes);
-    }
-
-    return strObjPtr;
-}
-
-static Jim_Obj *JimStringTrim(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *trimcharsObjPtr)
-{
-
-    Jim_Obj *objPtr = JimStringTrimLeft(interp, strObjPtr, trimcharsObjPtr);
-
-
-    strObjPtr = JimStringTrimRight(interp, objPtr, trimcharsObjPtr);
-
-
-    if (objPtr != strObjPtr && objPtr->refCount == 0) {
-
-        Jim_FreeNewObj(interp, objPtr);
-    }
-
-    return strObjPtr;
-}
-
-
-#ifdef HAVE_ISASCII
-#define jim_isascii isascii
-#else
-static int jim_isascii(int c)
-{
-    return !(c & ~0x7f);
-}
-#endif
-
-static int JimStringIs(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *strClass, int strict)
-{
-    static const char * const strclassnames[] = {
-        "integer", "alpha", "alnum", "ascii", "digit",
-        "double", "lower", "upper", "space", "xdigit",
-        "control", "print", "graph", "punct", "boolean",
-        NULL
-    };
-    enum {
-        STR_IS_INTEGER, STR_IS_ALPHA, STR_IS_ALNUM, STR_IS_ASCII, STR_IS_DIGIT,
-        STR_IS_DOUBLE, STR_IS_LOWER, STR_IS_UPPER, STR_IS_SPACE, STR_IS_XDIGIT,
-        STR_IS_CONTROL, STR_IS_PRINT, STR_IS_GRAPH, STR_IS_PUNCT, STR_IS_BOOLEAN,
-    };
-    int strclass;
-    int len;
-    int i;
-    const char *str;
-    int (*isclassfunc)(int c) = NULL;
-
-    if (Jim_GetEnum(interp, strClass, strclassnames, &strclass, "class", JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK) {
-        return JIM_ERR;
-    }
-
-    str = Jim_GetString(strObjPtr, &len);
-    if (len == 0) {
-        Jim_SetResultBool(interp, !strict);
-        return JIM_OK;
-    }
-
-    switch (strclass) {
-        case STR_IS_INTEGER:
-            {
-                jim_wide w;
-                Jim_SetResultBool(interp, JimGetWideNoErr(interp, strObjPtr, &w) == JIM_OK);
-                return JIM_OK;
-            }
-
-        case STR_IS_DOUBLE:
-            {
-                double d;
-                Jim_SetResultBool(interp, Jim_GetDouble(interp, strObjPtr, &d) == JIM_OK && errno != ERANGE);
-                return JIM_OK;
-            }
-
-        case STR_IS_BOOLEAN:
-            {
-                int b;
-                Jim_SetResultBool(interp, Jim_GetBoolean(interp, strObjPtr, &b) == JIM_OK);
-                return JIM_OK;
-            }
-
-        case STR_IS_ALPHA: isclassfunc = isalpha; break;
-        case STR_IS_ALNUM: isclassfunc = isalnum; break;
-        case STR_IS_ASCII: isclassfunc = jim_isascii; break;
-        case STR_IS_DIGIT: isclassfunc = isdigit; break;
-        case STR_IS_LOWER: isclassfunc = islower; break;
-        case STR_IS_UPPER: isclassfunc = isupper; break;
-        case STR_IS_SPACE: isclassfunc = isspace; break;
-        case STR_IS_XDIGIT: isclassfunc = isxdigit; break;
-        case STR_IS_CONTROL: isclassfunc = iscntrl; break;
-        case STR_IS_PRINT: isclassfunc = isprint; break;
-        case STR_IS_GRAPH: isclassfunc = isgraph; break;
-        case STR_IS_PUNCT: isclassfunc = ispunct; break;
-        default:
-            return JIM_ERR;
-    }
-
-    for (i = 0; i < len; i++) {
-        if (!isclassfunc(UCHAR(str[i]))) {
-            Jim_SetResultBool(interp, 0);
-            return JIM_OK;
-        }
-    }
-    Jim_SetResultBool(interp, 1);
-    return JIM_OK;
-}
-
-
-
-static const Jim_ObjType comparedStringObjType = {
-    "compared-string",
-    NULL,
-    NULL,
-    NULL,
-    JIM_TYPE_REFERENCES,
-};
-
-int Jim_CompareStringImmediate(Jim_Interp *interp, Jim_Obj *objPtr, const char *str)
-{
-    if (objPtr->typePtr == &comparedStringObjType && objPtr->internalRep.ptr == str) {
-        return 1;
-    }
-    else {
-        if (strcmp(str, Jim_String(objPtr)) != 0)
-            return 0;
-
-        if (objPtr->typePtr != &comparedStringObjType) {
-            Jim_FreeIntRep(interp, objPtr);
-            objPtr->typePtr = &comparedStringObjType;
-        }
-        objPtr->internalRep.ptr = (char *)str;
-        return 1;
-    }
-}
-
-static int qsortCompareStringPointers(const void *a, const void *b)
-{
-    char *const *sa = (char *const *)a;
-    char *const *sb = (char *const *)b;
-
-    return strcmp(*sa, *sb);
-}
-
-
-
-static void FreeSourceInternalRep(Jim_Interp *interp, Jim_Obj *objPtr);
-static void DupSourceInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
-
-static const Jim_ObjType sourceObjType = {
-    "source",
-    FreeSourceInternalRep,
-    DupSourceInternalRep,
-    NULL,
-    JIM_TYPE_REFERENCES,
-};
-
-void FreeSourceInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    Jim_DecrRefCount(interp, objPtr->internalRep.sourceValue.fileNameObj);
-}
-
-void DupSourceInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
-{
-    dupPtr->internalRep.sourceValue = srcPtr->internalRep.sourceValue;
-    Jim_IncrRefCount(dupPtr->internalRep.sourceValue.fileNameObj);
-}
-
-static const Jim_ObjType scriptLineObjType = {
-    "scriptline",
-    NULL,
-    NULL,
-    NULL,
-    JIM_NONE,
-};
-
-static Jim_Obj *JimNewScriptLineObj(Jim_Interp *interp, int argc, int line)
-{
-    Jim_Obj *objPtr;
-
-#ifdef DEBUG_SHOW_SCRIPT
-    char buf[100];
-    snprintf(buf, sizeof(buf), "line=%d, argc=%d", line, argc);
-    objPtr = Jim_NewStringObj(interp, buf, -1);
-#else
-    objPtr = Jim_NewEmptyStringObj(interp);
-#endif
-    objPtr->typePtr = &scriptLineObjType;
-    objPtr->internalRep.scriptLineValue.argc = argc;
-    objPtr->internalRep.scriptLineValue.line = line;
-
-    return objPtr;
-}
-
-static void FreeScriptInternalRep(Jim_Interp *interp, Jim_Obj *objPtr);
-static void DupScriptInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
-
-static const Jim_ObjType scriptObjType = {
-    "script",
-    FreeScriptInternalRep,
-    DupScriptInternalRep,
-    NULL,
-    JIM_TYPE_NONE,
-};
-
-typedef struct ScriptToken
-{
-    Jim_Obj *objPtr;
-    int type;
-} ScriptToken;
-
-typedef struct ScriptObj
-{
-    ScriptToken *token;
-    Jim_Obj *fileNameObj;
-    int len;
-    int substFlags;
-    int inUse;                  /* Used to share a ScriptObj. Currently
-                                   only used by Jim_EvalObj() as protection against
-                                   shimmering of the currently evaluated object. */
-    int firstline;
-    int linenr;
-    int missing;
-} ScriptObj;
-
-static void JimSetScriptFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
-static int JimParseCheckMissing(Jim_Interp *interp, int ch);
-static ScriptObj *JimGetScript(Jim_Interp *interp, Jim_Obj *objPtr);
-static void JimSetErrorStack(Jim_Interp *interp, ScriptObj *script);
-
-void FreeScriptInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    int i;
-    struct ScriptObj *script = (void *)objPtr->internalRep.ptr;
-
-    if (--script->inUse != 0)
-        return;
-    for (i = 0; i < script->len; i++) {
-        Jim_DecrRefCount(interp, script->token[i].objPtr);
-    }
-    Jim_Free(script->token);
-    Jim_DecrRefCount(interp, script->fileNameObj);
-    Jim_Free(script);
-}
-
-void DupScriptInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
-{
-    JIM_NOTUSED(interp);
-    JIM_NOTUSED(srcPtr);
-
-    dupPtr->typePtr = NULL;
-}
-
-typedef struct
-{
-    const char *token;
-    int len;
-    int type;
-    int line;
-} ParseToken;
-
-typedef struct
-{
-
-    ParseToken *list;
-    int size;
-    int count;
-    ParseToken static_list[20];
-} ParseTokenList;
-
-static void ScriptTokenListInit(ParseTokenList *tokenlist)
-{
-    tokenlist->list = tokenlist->static_list;
-    tokenlist->size = sizeof(tokenlist->static_list) / sizeof(ParseToken);
-    tokenlist->count = 0;
-}
-
-static void ScriptTokenListFree(ParseTokenList *tokenlist)
-{
-    if (tokenlist->list != tokenlist->static_list) {
-        Jim_Free(tokenlist->list);
-    }
-}
-
-static void ScriptAddToken(ParseTokenList *tokenlist, const char *token, int len, int type,
-    int line)
-{
-    ParseToken *t;
-
-    if (tokenlist->count == tokenlist->size) {
-
-        tokenlist->size *= 2;
-        if (tokenlist->list != tokenlist->static_list) {
-            tokenlist->list =
-                Jim_Realloc(tokenlist->list, tokenlist->size * sizeof(*tokenlist->list));
-        }
-        else {
-
-            tokenlist->list = Jim_Alloc(tokenlist->size * sizeof(*tokenlist->list));
-            memcpy(tokenlist->list, tokenlist->static_list,
-                tokenlist->count * sizeof(*tokenlist->list));
-        }
-    }
-    t = &tokenlist->list[tokenlist->count++];
-    t->token = token;
-    t->len = len;
-    t->type = type;
-    t->line = line;
-}
-
-static int JimCountWordTokens(struct ScriptObj *script, ParseToken *t)
-{
-    int expand = 1;
-    int count = 0;
-
-
-    if (t->type == JIM_TT_STR && !TOKEN_IS_SEP(t[1].type)) {
-        if ((t->len == 1 && *t->token == '*') || (t->len == 6 && strncmp(t->token, "expand", 6) == 0)) {
-
-            expand = -1;
-            t++;
-        }
-        else {
-            if (script->missing == ' ') {
-
-                script->missing = '}';
-                script->linenr = t[1].line;
-            }
-        }
-    }
-
-
-    while (!TOKEN_IS_SEP(t->type)) {
-        t++;
-        count++;
-    }
-
-    return count * expand;
-}
-
-static Jim_Obj *JimMakeScriptObj(Jim_Interp *interp, const ParseToken *t)
-{
-    Jim_Obj *objPtr;
-
-    if (t->type == JIM_TT_ESC && memchr(t->token, '\\', t->len) != NULL) {
-
-        int len = t->len;
-        char *str = Jim_Alloc(len + 1);
-        len = JimEscape(str, t->token, len);
-        objPtr = Jim_NewStringObjNoAlloc(interp, str, len);
-    }
-    else {
-        objPtr = Jim_NewStringObj(interp, t->token, t->len);
-    }
-    return objPtr;
-}
-
-static void ScriptObjAddTokens(Jim_Interp *interp, struct ScriptObj *script,
-    ParseTokenList *tokenlist)
-{
-    int i;
-    struct ScriptToken *token;
-
-    int lineargs = 0;
-
-    ScriptToken *linefirst;
-    int count;
-    int linenr;
-
-#ifdef DEBUG_SHOW_SCRIPT_TOKENS
-    printf("==== Tokens ====\n");
-    for (i = 0; i < tokenlist->count; i++) {
-        printf("[%2d]@%d %s '%.*s'\n", i, tokenlist->list[i].line, jim_tt_name(tokenlist->list[i].type),
-            tokenlist->list[i].len, tokenlist->list[i].token);
-    }
-#endif
-
-
-    count = tokenlist->count;
-    for (i = 0; i < tokenlist->count; i++) {
-        if (tokenlist->list[i].type == JIM_TT_EOL) {
-            count++;
-        }
-    }
-    linenr = script->firstline = tokenlist->list[0].line;
-
-    token = script->token = Jim_Alloc(sizeof(ScriptToken) * count);
-
-
-    linefirst = token++;
-
-    for (i = 0; i < tokenlist->count; ) {
-
-        int wordtokens;
-
-
-        while (tokenlist->list[i].type == JIM_TT_SEP) {
-            i++;
-        }
-
-        wordtokens = JimCountWordTokens(script, tokenlist->list + i);
-
-        if (wordtokens == 0) {
-
-            if (lineargs) {
-                linefirst->type = JIM_TT_LINE;
-                linefirst->objPtr = JimNewScriptLineObj(interp, lineargs, linenr);
-                Jim_IncrRefCount(linefirst->objPtr);
-
-
-                lineargs = 0;
-                linefirst = token++;
-            }
-            i++;
-            continue;
-        }
-        else if (wordtokens != 1) {
-
-            token->type = JIM_TT_WORD;
-            token->objPtr = Jim_NewIntObj(interp, wordtokens);
-            Jim_IncrRefCount(token->objPtr);
-            token++;
-            if (wordtokens < 0) {
-
-                i++;
-                wordtokens = -wordtokens - 1;
-                lineargs--;
-            }
-        }
-
-        if (lineargs == 0) {
-
-            linenr = tokenlist->list[i].line;
-        }
-        lineargs++;
-
-
-        while (wordtokens--) {
-            const ParseToken *t = &tokenlist->list[i++];
-
-            token->type = t->type;
-            token->objPtr = JimMakeScriptObj(interp, t);
-            Jim_IncrRefCount(token->objPtr);
-
-            Jim_SetSourceInfo(interp, token->objPtr, script->fileNameObj, t->line);
-            token++;
-        }
-    }
-
-    if (lineargs == 0) {
-        token--;
-    }
-
-    script->len = token - script->token;
-
-    JimPanic((script->len >= count, "allocated script array is too short"));
-
-#ifdef DEBUG_SHOW_SCRIPT
-    printf("==== Script (%s) ====\n", Jim_String(script->fileNameObj));
-    for (i = 0; i < script->len; i++) {
-        const ScriptToken *t = &script->token[i];
-        printf("[%2d] %s %s\n", i, jim_tt_name(t->type), Jim_String(t->objPtr));
-    }
-#endif
-
-}
-
-int Jim_ScriptIsComplete(Jim_Interp *interp, Jim_Obj *scriptObj, char *stateCharPtr)
-{
-    ScriptObj *script = JimGetScript(interp, scriptObj);
-    if (stateCharPtr) {
-        *stateCharPtr = script->missing;
-    }
-    return script->missing == ' ' || script->missing == '}';
-}
-
-static int JimParseCheckMissing(Jim_Interp *interp, int ch)
-{
-    const char *msg;
-
-    switch (ch) {
-        case '\\':
-        case ' ':
-            return JIM_OK;
-
-        case '[':
-            msg = "unmatched \"[\"";
-            break;
-        case '{':
-            msg = "missing close-brace";
-            break;
-        case '}':
-            msg = "extra characters after close-brace";
-            break;
-        case '"':
-        default:
-            msg = "missing quote";
-            break;
-    }
-
-    Jim_SetResultString(interp, msg, -1);
-    return JIM_ERR;
-}
-
-Jim_Obj *Jim_GetSourceInfo(Jim_Interp *interp, Jim_Obj *objPtr, int *lineptr)
-{
-    int line;
-    Jim_Obj *fileNameObj;
-
-    if (objPtr->typePtr == &sourceObjType) {
-        fileNameObj = objPtr->internalRep.sourceValue.fileNameObj;
-        line = objPtr->internalRep.sourceValue.lineNumber;
-    }
-    else if (objPtr->typePtr == &scriptObjType) {
-        ScriptObj *script = JimGetScript(interp, objPtr);
-        fileNameObj = script->fileNameObj;
-        line = script->firstline;
-    }
-    else {
-        fileNameObj = interp->emptyObj;
-        line = 1;
-    }
-    *lineptr = line;
-    return fileNameObj;
-}
-
-void Jim_SetSourceInfo(Jim_Interp *interp, Jim_Obj *objPtr,
-    Jim_Obj *fileNameObj, int lineNumber)
-{
-    JimPanic((Jim_IsShared(objPtr), "Jim_SetSourceInfo called with shared object"));
-    Jim_FreeIntRep(interp, objPtr);
-    Jim_IncrRefCount(fileNameObj);
-    objPtr->internalRep.sourceValue.fileNameObj = fileNameObj;
-    objPtr->internalRep.sourceValue.lineNumber = lineNumber;
-    objPtr->typePtr = &sourceObjType;
-}
-
-static void SubstObjAddTokens(Jim_Interp *interp, struct ScriptObj *script,
-    ParseTokenList *tokenlist)
-{
-    int i;
-    struct ScriptToken *token;
-
-    token = script->token = Jim_Alloc(sizeof(ScriptToken) * tokenlist->count);
-
-    for (i = 0; i < tokenlist->count; i++) {
-        const ParseToken *t = &tokenlist->list[i];
-
-
-        token->type = t->type;
-        token->objPtr = JimMakeScriptObj(interp, t);
-        Jim_IncrRefCount(token->objPtr);
-        token++;
-    }
-
-    script->len = i;
-}
-
-static void JimSetScriptFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
-{
-    int scriptTextLen;
-    const char *scriptText = Jim_GetString(objPtr, &scriptTextLen);
-    struct JimParserCtx parser;
-    struct ScriptObj *script;
-    ParseTokenList tokenlist;
-    Jim_Obj *fileNameObj;
-    int line;
-
-
-    fileNameObj = Jim_GetSourceInfo(interp, objPtr, &line);
-
-
-    ScriptTokenListInit(&tokenlist);
-
-    JimParserInit(&parser, scriptText, scriptTextLen, line);
-    while (!parser.eof) {
-        JimParseScript(&parser);
-        ScriptAddToken(&tokenlist, parser.tstart, parser.tend - parser.tstart + 1, parser.tt,
-            parser.tline);
-    }
-
-
-    ScriptAddToken(&tokenlist, scriptText + scriptTextLen, 0, JIM_TT_EOF, 0);
-
-
-    script = Jim_Alloc(sizeof(*script));
-    memset(script, 0, sizeof(*script));
-    script->inUse = 1;
-    script->fileNameObj = fileNameObj;
-    Jim_IncrRefCount(script->fileNameObj);
-    script->missing = parser.missing.ch;
-    script->linenr = parser.missing.line;
-
-    ScriptObjAddTokens(interp, script, &tokenlist);
-
-
-    ScriptTokenListFree(&tokenlist);
-
-
-    Jim_FreeIntRep(interp, objPtr);
-    Jim_SetIntRepPtr(objPtr, script);
-    objPtr->typePtr = &scriptObjType;
-}
-
-static ScriptObj *JimGetScript(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    if (objPtr == interp->emptyObj) {
-
-        objPtr = interp->nullScriptObj;
-    }
-
-    if (objPtr->typePtr != &scriptObjType || ((struct ScriptObj *)Jim_GetIntRepPtr(objPtr))->substFlags) {
-        JimSetScriptFromAny(interp, objPtr);
-    }
-
-    return (ScriptObj *)Jim_GetIntRepPtr(objPtr);
-}
-
-void Jim_InterpIncrProcEpoch(Jim_Interp *interp)
-{
-    interp->procEpoch++;
-
-
-    while (interp->oldCmdCache) {
-        Jim_Cmd *next = interp->oldCmdCache->prevCmd;
-        Jim_Free(interp->oldCmdCache);
-        interp->oldCmdCache = next;
-    }
-    interp->oldCmdCacheSize = 0;
-}
-
-static void JimIncrCmdRefCount(Jim_Cmd *cmdPtr)
-{
-    cmdPtr->inUse++;
-}
-
-static void JimDecrCmdRefCount(Jim_Interp *interp, Jim_Cmd *cmdPtr)
-{
-    if (--cmdPtr->inUse == 0) {
-        if (cmdPtr->isproc) {
-            Jim_DecrRefCount(interp, cmdPtr->u.proc.argListObjPtr);
-            Jim_DecrRefCount(interp, cmdPtr->u.proc.bodyObjPtr);
-            Jim_DecrRefCount(interp, cmdPtr->u.proc.nsObj);
-            if (cmdPtr->u.proc.staticVars) {
-                Jim_FreeHashTable(cmdPtr->u.proc.staticVars);
-                Jim_Free(cmdPtr->u.proc.staticVars);
-            }
-        }
-        else {
-
-            if (cmdPtr->u.native.delProc) {
-                cmdPtr->u.native.delProc(interp, cmdPtr->u.native.privData);
-            }
-        }
-        if (cmdPtr->prevCmd) {
-
-            JimDecrCmdRefCount(interp, cmdPtr->prevCmd);
-        }
-
-        cmdPtr->prevCmd = interp->oldCmdCache;
-        interp->oldCmdCache = cmdPtr;
-        if (!interp->quitting && ++interp->oldCmdCacheSize >= 1000) {
-            Jim_InterpIncrProcEpoch(interp);
-        }
-    }
-}
-
-static void JimIncrVarRef(Jim_VarVal *vv)
-{
-    vv->refCount++;
-}
-
-static void JimDecrVarRef(Jim_Interp *interp, Jim_VarVal *vv)
-{
-    assert(vv->refCount > 0);
-    if (--vv->refCount == 0) {
-        if (vv->objPtr) {
-            Jim_DecrRefCount(interp, vv->objPtr);
-        }
-        Jim_Free(vv);
-    }
-}
-
-static void JimVariablesHTValDestructor(void *interp, void *val)
-{
-    JimDecrVarRef(interp, val);
-}
-
-static unsigned int JimObjectHTHashFunction(const void *key)
-{
-    Jim_Obj *keyObj = (Jim_Obj *)key;
-    int length;
-    const char *string;
-
-#ifdef JIM_OPTIMIZATION
-    if (JimIsWide(keyObj) && keyObj->bytes == NULL) {
-
-        jim_wide objValue = JimWideValue(keyObj);
-        if (objValue > INT_MIN && objValue < INT_MAX) {
-            unsigned result = 0;
-            unsigned value = (unsigned)objValue;
-
-            if (objValue < 0) {
-                value = (unsigned)-objValue;
-            }
-
-
-            do {
-                result += (result << 3) + (value % 10 + '0');
-                value /= 10;
-            } while (value);
-
-            if (objValue < 0) {
-                result += (result << 3) + '-';
-            }
-            return result;
-        }
-    }
-#endif
-    string = Jim_GetString(keyObj, &length);
-    return Jim_GenHashFunction((const unsigned char *)string, length);
-}
-
-static int JimObjectHTKeyCompare(void *privdata, const void *key1, const void *key2)
-{
-    return Jim_StringEqObj((Jim_Obj *)key1, (Jim_Obj *)key2);
-}
-
-static void *JimObjectHTKeyValDup(void *privdata, const void *val)
-{
-    Jim_IncrRefCount((Jim_Obj *)val);
-    return (void *)val;
-}
-
-static void JimObjectHTKeyValDestructor(void *interp, void *val)
-{
-    Jim_DecrRefCount(interp, (Jim_Obj *)val);
-}
-
-
-static void *JimVariablesHTValDup(void *privdata, const void *val)
-{
-    JimIncrVarRef((Jim_VarVal *)val);
-    return (void *)val;
-}
-
-static const Jim_HashTableType JimVariablesHashTableType = {
-    JimObjectHTHashFunction,
-    JimObjectHTKeyValDup,
-    JimVariablesHTValDup,
-    JimObjectHTKeyCompare,
-    JimObjectHTKeyValDestructor,
-    JimVariablesHTValDestructor
-};
-
-
-static const char *Jim_GetStringNoQualifier(Jim_Obj *objPtr, int *length)
-{
-    int len;
-    const char *str = Jim_GetString(objPtr, &len);
-    if (len >= 2 && str[0] == ':' && str[1] == ':') {
-        while (len && *str == ':') {
-            len--;
-            str++;
-        }
-    }
-    *length = len;
-    return str;
-}
-
-static unsigned int JimCommandsHT_HashFunction(const void *key)
-{
-    int len;
-    const char *str = Jim_GetStringNoQualifier((Jim_Obj *)key, &len);
-    return Jim_GenHashFunction((const unsigned char *)str, len);
-}
-
-static int JimCommandsHT_KeyCompare(void *privdata, const void *key1, const void *key2)
-{
-    int len1, len2;
-    const char *str1 = Jim_GetStringNoQualifier((Jim_Obj *)key1, &len1);
-    const char *str2 = Jim_GetStringNoQualifier((Jim_Obj *)key2, &len2);
-    return len1 == len2 && memcmp(str1, str2, len1) == 0;
-}
-
-static void JimCommandsHT_ValDestructor(void *interp, void *val)
-{
-    JimDecrCmdRefCount(interp, val);
-}
-
-static const Jim_HashTableType JimCommandsHashTableType = {
-    JimCommandsHT_HashFunction,
-    JimObjectHTKeyValDup,
-    NULL,
-    JimCommandsHT_KeyCompare,
-    JimObjectHTKeyValDestructor,
-    JimCommandsHT_ValDestructor
-};
-
-
-
-Jim_Obj *Jim_MakeGlobalNamespaceName(Jim_Interp *interp, Jim_Obj *nameObjPtr)
-{
-#ifdef jim_ext_namespace
-    Jim_Obj *resultObj;
-
-    const char *name = Jim_String(nameObjPtr);
-    if (name[0] == ':' && name[1] == ':') {
-        return nameObjPtr;
-    }
-    Jim_IncrRefCount(nameObjPtr);
-    resultObj = Jim_NewStringObj(interp, "::", -1);
-    Jim_AppendObj(interp, resultObj, nameObjPtr);
-    Jim_DecrRefCount(interp, nameObjPtr);
-
-    return resultObj;
-#else
-    return nameObjPtr;
-#endif
-}
-
-static Jim_Obj *JimQualifyName(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-#ifdef jim_ext_namespace
-    if (Jim_Length(interp->framePtr->nsObj)) {
-        int len;
-        const char *name = Jim_GetString(objPtr, &len);
-        if (len < 2 || name[0] != ':' || name[1] != ':') {
-
-            objPtr = Jim_DuplicateObj(interp, interp->framePtr->nsObj);
-            Jim_AppendStrings(interp, objPtr, "::", name, NULL);
-        }
-    }
-#endif
-    Jim_IncrRefCount(objPtr);
-    return objPtr;
-}
-
-static void JimCreateCommand(Jim_Interp *interp, Jim_Obj *nameObjPtr, Jim_Cmd *cmd)
-{
-    JimPanic((nameObjPtr->refCount == 0, "JimCreateCommand called with zero ref count name"));
-
-    if (interp->local) {
-        Jim_HashEntry *he = Jim_FindHashEntry(&interp->commands, nameObjPtr);
-        if (he) {
-
-            cmd->prevCmd = Jim_GetHashEntryVal(he);
-            Jim_SetHashVal(&interp->commands, he, cmd);
-
-            Jim_InterpIncrProcEpoch(interp);
-            return;
-        }
-    }
-
-
-
-    Jim_ReplaceHashEntry(&interp->commands, nameObjPtr, cmd);
-}
-
-int Jim_CreateCommandObj(Jim_Interp *interp, Jim_Obj *cmdNameObj,
-    Jim_CmdProc *cmdProc, void *privData, Jim_DelCmdProc *delProc)
-{
-    Jim_Cmd *cmdPtr = Jim_Alloc(sizeof(*cmdPtr));
-
-
-    memset(cmdPtr, 0, sizeof(*cmdPtr));
-    cmdPtr->inUse = 1;
-    cmdPtr->u.native.delProc = delProc;
-    cmdPtr->u.native.cmdProc = cmdProc;
-    cmdPtr->u.native.privData = privData;
-
-    Jim_IncrRefCount(cmdNameObj);
-    JimCreateCommand(interp, cmdNameObj, cmdPtr);
-    Jim_DecrRefCount(interp, cmdNameObj);
-
-    return JIM_OK;
-}
-
-
-int Jim_CreateCommand(Jim_Interp *interp, const char *cmdNameStr,
-    Jim_CmdProc *cmdProc, void *privData, Jim_DelCmdProc *delProc)
-{
-    return Jim_CreateCommandObj(interp, Jim_NewStringObj(interp, cmdNameStr, -1), cmdProc, privData, delProc);
-}
-
-static int JimCreateProcedureStatics(Jim_Interp *interp, Jim_Cmd *cmdPtr, Jim_Obj *staticsListObjPtr)
-{
-    int len, i;
-
-    len = Jim_ListLength(interp, staticsListObjPtr);
-    if (len == 0) {
-        return JIM_OK;
-    }
-
-    cmdPtr->u.proc.staticVars = Jim_Alloc(sizeof(Jim_HashTable));
-    Jim_InitHashTable(cmdPtr->u.proc.staticVars, &JimVariablesHashTableType, interp);
-    for (i = 0; i < len; i++) {
-        Jim_Obj *initObjPtr = NULL;
-        Jim_Obj *nameObjPtr;
-        Jim_VarVal *vv = NULL;
-        Jim_Obj *objPtr = Jim_ListGetIndex(interp, staticsListObjPtr, i);
-        int subLen = Jim_ListLength(interp, objPtr);
-        int byref = 0;
-
-
-        if (subLen != 1 && subLen != 2) {
-            Jim_SetResultFormatted(interp, "too many fields in static specifier \"%#s\"",
-                objPtr);
-            return JIM_ERR;
-        }
-
-        nameObjPtr = Jim_ListGetIndex(interp, objPtr, 0);
-
-
-        if (subLen == 1) {
-            int len;
-            const char *pt = Jim_GetString(nameObjPtr, &len);
-            if (*pt == '&') {
-
-                nameObjPtr = Jim_NewStringObj(interp, pt + 1, len - 1);
-                byref = 1;
-            }
-        }
-        Jim_IncrRefCount(nameObjPtr);
-
-        if (subLen == 1) {
-            switch (SetVariableFromAny(interp, nameObjPtr)) {
-                case JIM_DICT_SUGAR:
-
-                    if (byref) {
-                        Jim_SetResultFormatted(interp, "Can't link to array element \"%#s\"", nameObjPtr);
-                    }
-                    else {
-                        Jim_SetResultFormatted(interp, "Can't initialise array element \"%#s\"", nameObjPtr);
-                    }
-                    Jim_DecrRefCount(interp, nameObjPtr);
-                    return JIM_ERR;
-
-                case JIM_OK:
-                    if (byref) {
-                        vv = nameObjPtr->internalRep.varValue.vv;
-                    }
-                    else {
-                        initObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_NONE);
-                    }
-                    break;
-
-                case JIM_ERR:
-
-                    Jim_SetResultFormatted(interp,
-                        "variable for initialization of static \"%#s\" not found in the local context",
-                        nameObjPtr);
-                    Jim_DecrRefCount(interp, nameObjPtr);
-                    return JIM_ERR;
-            }
-        }
-        else {
-            initObjPtr = Jim_ListGetIndex(interp, objPtr, 1);
-        }
-
-        if (vv == NULL) {
-            vv = Jim_Alloc(sizeof(*vv));
-            vv->objPtr = initObjPtr;
-            Jim_IncrRefCount(vv->objPtr);
-            vv->linkFramePtr = NULL;
-            vv->refCount = 0;
-        }
-
-        if (JimSetNewVariable(cmdPtr->u.proc.staticVars, nameObjPtr, vv) != JIM_OK) {
-            Jim_SetResultFormatted(interp,
-                "static variable name \"%#s\" duplicated in statics list", nameObjPtr);
-            JimIncrVarRef(vv);
-            JimDecrVarRef(interp, vv);
-            Jim_DecrRefCount(interp, nameObjPtr);
-            return JIM_ERR;
-        }
-
-        Jim_DecrRefCount(interp, nameObjPtr);
-    }
-    return JIM_OK;
-}
-
-
-#ifdef jim_ext_namespace
-static const char *Jim_memrchr(const char *p, int c, int len)
-{
-    int i;
-    for (i = len; i > 0; i--) {
-        if (p[i] == c) {
-            return p + i;
-        }
-    }
-    return NULL;
-}
-#endif
-
-static void JimUpdateProcNamespace(Jim_Interp *interp, Jim_Cmd *cmdPtr, Jim_Obj *nameObjPtr)
-{
-#ifdef jim_ext_namespace
-    if (cmdPtr->isproc) {
-        int len;
-        const char *cmdname = Jim_GetStringNoQualifier(nameObjPtr, &len);
-
-        const char *pt = Jim_memrchr(cmdname, ':', len);
-        if (pt && pt != cmdname && pt[-1] == ':') {
-            pt++;
-            Jim_DecrRefCount(interp, cmdPtr->u.proc.nsObj);
-            cmdPtr->u.proc.nsObj = Jim_NewStringObj(interp, cmdname, pt - cmdname - 2);
-            Jim_IncrRefCount(cmdPtr->u.proc.nsObj);
-
-            Jim_Obj *tempObj = Jim_NewStringObj(interp, pt, len - (pt - cmdname));
-            if (Jim_FindHashEntry(&interp->commands, tempObj)) {
-
-                Jim_InterpIncrProcEpoch(interp);
-            }
-            Jim_FreeNewObj(interp, tempObj);
-        }
-    }
-#endif
-}
-
-static Jim_Cmd *JimCreateProcedureCmd(Jim_Interp *interp, Jim_Obj *argListObjPtr,
-    Jim_Obj *staticsListObjPtr, Jim_Obj *bodyObjPtr, Jim_Obj *nsObj)
-{
-    Jim_Cmd *cmdPtr;
-    int argListLen;
-    int i;
-
-    argListLen = Jim_ListLength(interp, argListObjPtr);
-
-
-    cmdPtr = Jim_Alloc(sizeof(*cmdPtr) + sizeof(struct Jim_ProcArg) * argListLen);
-    assert(cmdPtr);
-    memset(cmdPtr, 0, sizeof(*cmdPtr));
-    cmdPtr->inUse = 1;
-    cmdPtr->isproc = 1;
-    cmdPtr->u.proc.argListObjPtr = argListObjPtr;
-    cmdPtr->u.proc.argListLen = argListLen;
-    cmdPtr->u.proc.bodyObjPtr = bodyObjPtr;
-    cmdPtr->u.proc.argsPos = -1;
-    cmdPtr->u.proc.arglist = (struct Jim_ProcArg *)(cmdPtr + 1);
-    cmdPtr->u.proc.nsObj = nsObj ? nsObj : interp->emptyObj;
-    Jim_IncrRefCount(argListObjPtr);
-    Jim_IncrRefCount(bodyObjPtr);
-    Jim_IncrRefCount(cmdPtr->u.proc.nsObj);
-
-
-    if (staticsListObjPtr && JimCreateProcedureStatics(interp, cmdPtr, staticsListObjPtr) != JIM_OK) {
-        goto err;
-    }
-
-
-
-    for (i = 0; i < argListLen; i++) {
-        Jim_Obj *argPtr;
-        Jim_Obj *nameObjPtr;
-        Jim_Obj *defaultObjPtr;
-        int len;
-
-
-        argPtr = Jim_ListGetIndex(interp, argListObjPtr, i);
-        len = Jim_ListLength(interp, argPtr);
-        if (len == 0) {
-            Jim_SetResultString(interp, "argument with no name", -1);
-err:
-            JimDecrCmdRefCount(interp, cmdPtr);
-            return NULL;
-        }
-        if (len > 2) {
-            Jim_SetResultFormatted(interp, "too many fields in argument specifier \"%#s\"", argPtr);
-            goto err;
-        }
-
-        if (len == 2) {
-
-            nameObjPtr = Jim_ListGetIndex(interp, argPtr, 0);
-            defaultObjPtr = Jim_ListGetIndex(interp, argPtr, 1);
-        }
-        else {
-
-            nameObjPtr = argPtr;
-            defaultObjPtr = NULL;
-        }
-
-
-        if (Jim_CompareStringImmediate(interp, nameObjPtr, "args")) {
-            if (cmdPtr->u.proc.argsPos >= 0) {
-                Jim_SetResultString(interp, "'args' specified more than once", -1);
-                goto err;
-            }
-            cmdPtr->u.proc.argsPos = i;
-        }
-        else {
-            if (len == 2) {
-                cmdPtr->u.proc.optArity++;
-            }
-            else {
-                cmdPtr->u.proc.reqArity++;
-            }
-        }
-
-        cmdPtr->u.proc.arglist[i].nameObjPtr = nameObjPtr;
-        cmdPtr->u.proc.arglist[i].defaultObjPtr = defaultObjPtr;
-    }
-
-    return cmdPtr;
-}
-
-int Jim_DeleteCommand(Jim_Interp *interp, Jim_Obj *nameObj)
-{
-    int ret = JIM_OK;
-
-    nameObj = JimQualifyName(interp, nameObj);
-
-    if (Jim_DeleteHashEntry(&interp->commands, nameObj) == JIM_ERR) {
-        Jim_SetResultFormatted(interp, "can't delete \"%#s\": command doesn't exist", nameObj);
-        ret = JIM_ERR;
-    }
-    Jim_DecrRefCount(interp, nameObj);
-
-    return ret;
-}
-
-int Jim_RenameCommand(Jim_Interp *interp, Jim_Obj *oldNameObj, Jim_Obj *newNameObj)
-{
-    int ret = JIM_ERR;
-    Jim_HashEntry *he;
-    Jim_Cmd *cmdPtr;
-
-    if (Jim_Length(newNameObj) == 0) {
-        return Jim_DeleteCommand(interp, oldNameObj);
-    }
-
-
-
-    oldNameObj = JimQualifyName(interp, oldNameObj);
-    newNameObj = JimQualifyName(interp, newNameObj);
-
-
-    he = Jim_FindHashEntry(&interp->commands, oldNameObj);
-    if (he == NULL) {
-        Jim_SetResultFormatted(interp, "can't rename \"%#s\": command doesn't exist", oldNameObj);
-    }
-    else if (Jim_FindHashEntry(&interp->commands, newNameObj)) {
-        Jim_SetResultFormatted(interp, "can't rename to \"%#s\": command already exists", newNameObj);
-    }
-    else {
-        cmdPtr = Jim_GetHashEntryVal(he);
-        if (cmdPtr->prevCmd) {
-            Jim_SetResultFormatted(interp, "can't rename local command \"%#s\"", oldNameObj);
-        }
-        else {
-
-            JimIncrCmdRefCount(cmdPtr);
-            JimUpdateProcNamespace(interp, cmdPtr, newNameObj);
-            Jim_AddHashEntry(&interp->commands, newNameObj, cmdPtr);
-
-
-            Jim_DeleteHashEntry(&interp->commands, oldNameObj);
-
-
-            Jim_InterpIncrProcEpoch(interp);
-
-            ret = JIM_OK;
-        }
-    }
-
-    Jim_DecrRefCount(interp, oldNameObj);
-    Jim_DecrRefCount(interp, newNameObj);
-
-    return ret;
-}
-
-
-static void FreeCommandInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    Jim_DecrRefCount(interp, objPtr->internalRep.cmdValue.nsObj);
-}
-
-static void DupCommandInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
-{
-    dupPtr->internalRep.cmdValue = srcPtr->internalRep.cmdValue;
-    dupPtr->typePtr = srcPtr->typePtr;
-    Jim_IncrRefCount(dupPtr->internalRep.cmdValue.nsObj);
-}
-
-static const Jim_ObjType commandObjType = {
-    "command",
-    FreeCommandInternalRep,
-    DupCommandInternalRep,
-    NULL,
-    JIM_TYPE_REFERENCES,
-};
-
-Jim_Cmd *Jim_GetCommand(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
-{
-    Jim_Cmd *cmd;
-
-    if (objPtr->typePtr == &commandObjType
-        && objPtr->internalRep.cmdValue.procEpoch == interp->procEpoch
-#ifdef jim_ext_namespace
-        && Jim_StringEqObj(objPtr->internalRep.cmdValue.nsObj, interp->framePtr->nsObj)
-#endif
-        && objPtr->internalRep.cmdValue.cmdPtr->inUse) {
-
-        cmd = objPtr->internalRep.cmdValue.cmdPtr;
-    }
-    else {
-        Jim_Obj *qualifiedNameObj = JimQualifyName(interp, objPtr);
-        Jim_HashEntry *he = Jim_FindHashEntry(&interp->commands, qualifiedNameObj);
-#ifdef jim_ext_namespace
-        if (he == NULL && Jim_Length(interp->framePtr->nsObj)) {
-            he = Jim_FindHashEntry(&interp->commands, objPtr);
-        }
-#endif
-        if (he == NULL) {
-            if (flags & JIM_ERRMSG) {
-                Jim_SetResultFormatted(interp, "invalid command name \"%#s\"", objPtr);
-            }
-            Jim_DecrRefCount(interp, qualifiedNameObj);
-            return NULL;
-        }
-        cmd = Jim_GetHashEntryVal(he);
-
-        cmd->cmdNameObj = Jim_GetHashEntryKey(he);
-
-
-        Jim_FreeIntRep(interp, objPtr);
-        objPtr->typePtr = &commandObjType;
-        objPtr->internalRep.cmdValue.procEpoch = interp->procEpoch;
-        objPtr->internalRep.cmdValue.cmdPtr = cmd;
-        objPtr->internalRep.cmdValue.nsObj = interp->framePtr->nsObj;
-        Jim_IncrRefCount(interp->framePtr->nsObj);
-        Jim_DecrRefCount(interp, qualifiedNameObj);
-    }
-    while (cmd->u.proc.upcall) {
-        cmd = cmd->prevCmd;
-    }
-    return cmd;
-}
-
-
-
-static const Jim_ObjType variableObjType = {
-    "variable",
-    NULL,
-    NULL,
-    NULL,
-    JIM_TYPE_REFERENCES,
-};
-
-static int SetVariableFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
-{
-    const char *varName;
-    Jim_CallFrame *framePtr;
-    int global;
-    int len;
-    Jim_VarVal *vv;
-
-
-    if (objPtr->typePtr == &variableObjType) {
-        framePtr = objPtr->internalRep.varValue.global ? interp->topFramePtr : interp->framePtr;
-        if (objPtr->internalRep.varValue.callFrameId == framePtr->id) {
-
-            return JIM_OK;
-        }
-
-    }
-    else if (objPtr->typePtr == &dictSubstObjType) {
-        return JIM_DICT_SUGAR;
-    }
-
-    varName = Jim_GetString(objPtr, &len);
-
-
-    if (len && varName[len - 1] == ')' && strchr(varName, '(') != NULL) {
-        return JIM_DICT_SUGAR;
-    }
-
-    if (varName[0] == ':' && varName[1] == ':') {
-        while (*varName == ':') {
-            varName++;
-            len--;
-        }
-        global = 1;
-        framePtr = interp->topFramePtr;
-
-        Jim_Obj *tempObj = Jim_NewStringObj(interp, varName, len);
-        vv = JimFindVariable(&framePtr->vars, tempObj);
-        Jim_FreeNewObj(interp, tempObj);
-    }
-    else {
-        global = 0;
-        framePtr = interp->framePtr;
-
-        vv = JimFindVariable(&framePtr->vars, objPtr);
-        if (vv == NULL && framePtr->staticVars) {
-
-            vv = JimFindVariable(framePtr->staticVars, objPtr);
-        }
-    }
-
-    if (vv == NULL) {
-        return JIM_ERR;
-    }
-
-
-    Jim_FreeIntRep(interp, objPtr);
-    objPtr->typePtr = &variableObjType;
-    objPtr->internalRep.varValue.callFrameId = framePtr->id;
-    objPtr->internalRep.varValue.vv = vv;
-    objPtr->internalRep.varValue.global = global;
-    return JIM_OK;
-}
-
-
-static int JimDictSugarSet(Jim_Interp *interp, Jim_Obj *ObjPtr, Jim_Obj *valObjPtr);
-static Jim_Obj *JimDictSugarGet(Jim_Interp *interp, Jim_Obj *ObjPtr, int flags);
-
-static int JimSetNewVariable(Jim_HashTable *ht, Jim_Obj *nameObjPtr, Jim_VarVal *vv)
-{
-    return Jim_AddHashEntry(ht, nameObjPtr, vv);
-}
-
-static Jim_VarVal *JimFindVariable(Jim_HashTable *ht, Jim_Obj *nameObjPtr)
-{
-    Jim_HashEntry *he = Jim_FindHashEntry(ht, nameObjPtr);
-    if (he) {
-        return (Jim_VarVal *)Jim_GetHashEntryVal(he);
-    }
-    return NULL;
-}
-
-static int JimUnsetVariable(Jim_HashTable *ht, Jim_Obj *nameObjPtr)
-{
-    return Jim_DeleteHashEntry(ht, nameObjPtr);
-}
-
-static Jim_VarVal *JimCreateVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr)
-{
-    const char *name;
-    Jim_CallFrame *framePtr;
-    int global;
-    int len;
-
-
-    Jim_VarVal *vv = Jim_Alloc(sizeof(*vv));
-
-    vv->objPtr = valObjPtr;
-    Jim_IncrRefCount(valObjPtr);
-    vv->linkFramePtr = NULL;
-    vv->refCount = 0;
-
-    name = Jim_GetString(nameObjPtr, &len);
-    if (name[0] == ':' && name[1] == ':') {
-        while (*name == ':') {
-            name++;
-            len--;
-        }
-        framePtr = interp->topFramePtr;
-        global = 1;
-        JimSetNewVariable(&framePtr->vars, Jim_NewStringObj(interp, name, len), vv);
-    }
-    else {
-        framePtr = interp->framePtr;
-        global = 0;
-        JimSetNewVariable(&framePtr->vars, nameObjPtr, vv);
-    }
-
-
-    Jim_FreeIntRep(interp, nameObjPtr);
-    nameObjPtr->typePtr = &variableObjType;
-    nameObjPtr->internalRep.varValue.callFrameId = framePtr->id;
-    nameObjPtr->internalRep.varValue.vv = vv;
-    nameObjPtr->internalRep.varValue.global = global;
-
-    return vv;
-}
-
-int Jim_SetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr)
-{
-    int err;
-    Jim_VarVal *vv;
-
-    switch (SetVariableFromAny(interp, nameObjPtr)) {
-        case JIM_DICT_SUGAR:
-            return JimDictSugarSet(interp, nameObjPtr, valObjPtr);
-
-        case JIM_ERR:
-            JimCreateVariable(interp, nameObjPtr, valObjPtr);
-            break;
-
-        case JIM_OK:
-            vv = nameObjPtr->internalRep.varValue.vv;
-            if (vv->linkFramePtr == NULL) {
-                Jim_IncrRefCount(valObjPtr);
-                Jim_DecrRefCount(interp, vv->objPtr);
-                vv->objPtr = valObjPtr;
-            }
-            else {
-                Jim_CallFrame *savedCallFrame;
-
-                savedCallFrame = interp->framePtr;
-                interp->framePtr = vv->linkFramePtr;
-                err = Jim_SetVariable(interp, vv->objPtr, valObjPtr);
-                interp->framePtr = savedCallFrame;
-                if (err != JIM_OK)
-                    return err;
-            }
-    }
-    return JIM_OK;
-}
-
-int Jim_SetVariableStr(Jim_Interp *interp, const char *name, Jim_Obj *objPtr)
-{
-    Jim_Obj *nameObjPtr;
-    int result;
-
-    nameObjPtr = Jim_NewStringObj(interp, name, -1);
-    Jim_IncrRefCount(nameObjPtr);
-    result = Jim_SetVariable(interp, nameObjPtr, objPtr);
-    Jim_DecrRefCount(interp, nameObjPtr);
-    return result;
-}
-
-int Jim_SetGlobalVariableStr(Jim_Interp *interp, const char *name, Jim_Obj *objPtr)
-{
-    Jim_CallFrame *savedFramePtr;
-    int result;
-
-    savedFramePtr = interp->framePtr;
-    interp->framePtr = interp->topFramePtr;
-    result = Jim_SetVariableStr(interp, name, objPtr);
-    interp->framePtr = savedFramePtr;
-    return result;
-}
-
-int Jim_SetVariableStrWithStr(Jim_Interp *interp, const char *name, const char *val)
-{
-    Jim_Obj *valObjPtr;
-    int result;
-
-    valObjPtr = Jim_NewStringObj(interp, val, -1);
-    Jim_IncrRefCount(valObjPtr);
-    result = Jim_SetVariableStr(interp, name, valObjPtr);
-    Jim_DecrRefCount(interp, valObjPtr);
-    return result;
-}
-
-int Jim_SetVariableLink(Jim_Interp *interp, Jim_Obj *nameObjPtr,
-    Jim_Obj *targetNameObjPtr, Jim_CallFrame *targetCallFrame)
-{
-    const char *varName;
-    const char *targetName;
-    Jim_CallFrame *framePtr;
-    Jim_VarVal *vv;
-    int len;
-    int varnamelen;
-
-
-    switch (SetVariableFromAny(interp, nameObjPtr)) {
-        case JIM_DICT_SUGAR:
-
-            Jim_SetResultFormatted(interp, "bad variable name \"%#s\": upvar won't create a scalar variable that looks like an array element", nameObjPtr);
-            return JIM_ERR;
-
-        case JIM_OK:
-            vv = nameObjPtr->internalRep.varValue.vv;
-
-            if (vv->linkFramePtr == NULL) {
-                Jim_SetResultFormatted(interp, "variable \"%#s\" already exists", nameObjPtr);
-                return JIM_ERR;
-            }
-
-
-            vv->linkFramePtr = NULL;
-            break;
-    }
-
-
-
-    varName = Jim_GetString(nameObjPtr, &varnamelen);
-
-    if (varName[0] == ':' && varName[1] == ':') {
-        while (*varName == ':') {
-            varName++;
-            varnamelen--;
-        }
-
-        framePtr = interp->topFramePtr;
-    }
-    else {
-        framePtr = interp->framePtr;
-    }
-
-    targetName = Jim_GetString(targetNameObjPtr, &len);
-    if (targetName[0] == ':' && targetName[1] == ':') {
-        while (*targetName == ':') {
-            targetName++;
-            len--;
-        }
-        targetNameObjPtr = Jim_NewStringObj(interp, targetName, len);
-        targetCallFrame = interp->topFramePtr;
-    }
-    Jim_IncrRefCount(targetNameObjPtr);
-
-    if (framePtr->level < targetCallFrame->level) {
-        Jim_SetResultFormatted(interp,
-            "bad variable name \"%#s\": upvar won't create namespace variable that refers to procedure variable",
-            nameObjPtr);
-        Jim_DecrRefCount(interp, targetNameObjPtr);
-        return JIM_ERR;
-    }
-
-
-    if (framePtr == targetCallFrame) {
-        Jim_Obj *objPtr = targetNameObjPtr;
-
-
-        while (1) {
-            if (Jim_Length(objPtr) == varnamelen && memcmp(Jim_String(objPtr), varName, varnamelen) == 0) {
-                Jim_SetResultString(interp, "can't upvar from variable to itself", -1);
-                Jim_DecrRefCount(interp, targetNameObjPtr);
-                return JIM_ERR;
-            }
-            if (SetVariableFromAny(interp, objPtr) != JIM_OK)
-                break;
-            vv = objPtr->internalRep.varValue.vv;
-            if (vv->linkFramePtr != targetCallFrame)
-                break;
-            objPtr = vv->objPtr;
-        }
-    }
-
-
-    Jim_SetVariable(interp, nameObjPtr, targetNameObjPtr);
-
-    nameObjPtr->internalRep.varValue.vv->linkFramePtr = targetCallFrame;
-    Jim_DecrRefCount(interp, targetNameObjPtr);
-    return JIM_OK;
-}
-
-Jim_Obj *Jim_GetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
-{
-    if (interp->safeexpr) {
-        return nameObjPtr;
-    }
-    switch (SetVariableFromAny(interp, nameObjPtr)) {
-        case JIM_OK:{
-                Jim_VarVal *vv = nameObjPtr->internalRep.varValue.vv;
-
-                if (vv->linkFramePtr == NULL) {
-                    return vv->objPtr;
-                }
-                else {
-                    Jim_Obj *objPtr;
-
-
-                    Jim_CallFrame *savedCallFrame = interp->framePtr;
-
-                    interp->framePtr = vv->linkFramePtr;
-                    objPtr = Jim_GetVariable(interp, vv->objPtr, flags);
-                    interp->framePtr = savedCallFrame;
-                    if (objPtr) {
-                        return objPtr;
-                    }
-
-                }
-            }
-            break;
-
-        case JIM_DICT_SUGAR:
-
-            return JimDictSugarGet(interp, nameObjPtr, flags);
-    }
-    if (flags & JIM_ERRMSG) {
-        Jim_SetResultFormatted(interp, "can't read \"%#s\": no such variable", nameObjPtr);
-    }
-    return NULL;
-}
-
-Jim_Obj *Jim_GetGlobalVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
-{
-    Jim_CallFrame *savedFramePtr;
-    Jim_Obj *objPtr;
-
-    savedFramePtr = interp->framePtr;
-    interp->framePtr = interp->topFramePtr;
-    objPtr = Jim_GetVariable(interp, nameObjPtr, flags);
-    interp->framePtr = savedFramePtr;
-
-    return objPtr;
-}
-
-Jim_Obj *Jim_GetVariableStr(Jim_Interp *interp, const char *name, int flags)
-{
-    Jim_Obj *nameObjPtr, *varObjPtr;
-
-    nameObjPtr = Jim_NewStringObj(interp, name, -1);
-    Jim_IncrRefCount(nameObjPtr);
-    varObjPtr = Jim_GetVariable(interp, nameObjPtr, flags);
-    Jim_DecrRefCount(interp, nameObjPtr);
-    return varObjPtr;
-}
-
-Jim_Obj *Jim_GetGlobalVariableStr(Jim_Interp *interp, const char *name, int flags)
-{
-    Jim_CallFrame *savedFramePtr;
-    Jim_Obj *objPtr;
-
-    savedFramePtr = interp->framePtr;
-    interp->framePtr = interp->topFramePtr;
-    objPtr = Jim_GetVariableStr(interp, name, flags);
-    interp->framePtr = savedFramePtr;
-
-    return objPtr;
-}
-
-int Jim_UnsetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
-{
-    Jim_VarVal *vv;
-    int retval;
-    Jim_CallFrame *framePtr;
-
-    retval = SetVariableFromAny(interp, nameObjPtr);
-    if (retval == JIM_DICT_SUGAR) {
-
-        return JimDictSugarSet(interp, nameObjPtr, NULL);
-    }
-    else if (retval == JIM_OK) {
-        vv = nameObjPtr->internalRep.varValue.vv;
-
-
-        if (vv->linkFramePtr) {
-            framePtr = interp->framePtr;
-            interp->framePtr = vv->linkFramePtr;
-            retval = Jim_UnsetVariable(interp, vv->objPtr, JIM_NONE);
-            interp->framePtr = framePtr;
-        }
-        else {
-            if (nameObjPtr->internalRep.varValue.global) {
-                int len;
-                const char *name = Jim_GetString(nameObjPtr, &len);
-                while (*name == ':') {
-                    name++;
-                    len--;
-                }
-                framePtr = interp->topFramePtr;
-                Jim_Obj *tempObj = Jim_NewStringObj(interp, name, len);
-                retval = JimUnsetVariable(&framePtr->vars, tempObj);
-                Jim_FreeNewObj(interp, tempObj);
-            }
-            else {
-                framePtr = interp->framePtr;
-                retval = JimUnsetVariable(&framePtr->vars, nameObjPtr);
-            }
-
-            if (retval == JIM_OK) {
-
-                framePtr->id = interp->callFrameEpoch++;
-            }
-        }
-    }
-    if (retval != JIM_OK && (flags & JIM_ERRMSG)) {
-        Jim_SetResultFormatted(interp, "can't unset \"%#s\": no such variable", nameObjPtr);
-    }
-    return retval;
-}
-
-
-
-static void JimDictSugarParseVarKey(Jim_Interp *interp, Jim_Obj *objPtr,
-    Jim_Obj **varPtrPtr, Jim_Obj **keyPtrPtr)
-{
-    const char *str, *p;
-    int len, keyLen;
-    Jim_Obj *varObjPtr, *keyObjPtr;
-
-    str = Jim_GetString(objPtr, &len);
-
-    p = strchr(str, '(');
-    JimPanic((p == NULL, "JimDictSugarParseVarKey() called for non-dict-sugar (%s)", str));
-
-    varObjPtr = Jim_NewStringObj(interp, str, p - str);
-
-    p++;
-    keyLen = (str + len) - p;
-    if (str[len - 1] == ')') {
-        keyLen--;
-    }
-
-
-    keyObjPtr = Jim_NewStringObj(interp, p, keyLen);
-
-    Jim_IncrRefCount(varObjPtr);
-    Jim_IncrRefCount(keyObjPtr);
-    *varPtrPtr = varObjPtr;
-    *keyPtrPtr = keyObjPtr;
-}
-
-static int JimDictSugarSet(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *valObjPtr)
-{
-    int err;
-
-    SetDictSubstFromAny(interp, objPtr);
-
-    err = Jim_SetDictKeysVector(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr,
-        &objPtr->internalRep.dictSubstValue.indexObjPtr, 1, valObjPtr, JIM_MUSTEXIST);
-
-    if (err == JIM_OK) {
-
-        Jim_SetEmptyResult(interp);
-    }
-    else {
-        if (!valObjPtr) {
-
-            if (Jim_GetVariable(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr, JIM_NONE)) {
-                Jim_SetResultFormatted(interp, "can't unset \"%#s\": no such element in array",
-                    objPtr);
-                return err;
-            }
-        }
-
-        Jim_SetResultFormatted(interp, "can't %s \"%#s\": variable isn't array",
-            (valObjPtr ? "set" : "unset"), objPtr);
-    }
-    return err;
-}
-
-static Jim_Obj *JimDictExpandArrayVariable(Jim_Interp *interp, Jim_Obj *varObjPtr,
-    Jim_Obj *keyObjPtr, int flags)
-{
-    Jim_Obj *dictObjPtr;
-    Jim_Obj *resObjPtr = NULL;
-    int ret;
-
-    dictObjPtr = Jim_GetVariable(interp, varObjPtr, JIM_ERRMSG);
-    if (!dictObjPtr) {
-        return NULL;
-    }
-
-    ret = Jim_DictKey(interp, dictObjPtr, keyObjPtr, &resObjPtr, JIM_NONE);
-    if (ret != JIM_OK) {
-        Jim_SetResultFormatted(interp,
-            "can't read \"%#s(%#s)\": %s array", varObjPtr, keyObjPtr,
-            ret < 0 ? "variable isn't" : "no such element in");
-    }
-    else if ((flags & JIM_UNSHARED) && Jim_IsShared(dictObjPtr)) {
-
-        Jim_SetVariable(interp, varObjPtr, Jim_DuplicateObj(interp, dictObjPtr));
-    }
-
-    return resObjPtr;
-}
-
-
-static Jim_Obj *JimDictSugarGet(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
-{
-    SetDictSubstFromAny(interp, objPtr);
-
-    return JimDictExpandArrayVariable(interp,
-        objPtr->internalRep.dictSubstValue.varNameObjPtr,
-        objPtr->internalRep.dictSubstValue.indexObjPtr, flags);
-}
-
-
-
-void FreeDictSubstInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    Jim_DecrRefCount(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr);
-    Jim_DecrRefCount(interp, objPtr->internalRep.dictSubstValue.indexObjPtr);
-}
-
-static void DupDictSubstInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
-{
-
-    dupPtr->internalRep = srcPtr->internalRep;
-
-    Jim_IncrRefCount(dupPtr->internalRep.dictSubstValue.varNameObjPtr);
-    Jim_IncrRefCount(dupPtr->internalRep.dictSubstValue.indexObjPtr);
-}
-
-
-static void SetDictSubstFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    if (objPtr->typePtr != &dictSubstObjType) {
-        Jim_Obj *varObjPtr, *keyObjPtr;
-
-        if (objPtr->typePtr == &interpolatedObjType) {
-
-
-            varObjPtr = objPtr->internalRep.dictSubstValue.varNameObjPtr;
-            keyObjPtr = objPtr->internalRep.dictSubstValue.indexObjPtr;
-
-            Jim_IncrRefCount(varObjPtr);
-            Jim_IncrRefCount(keyObjPtr);
-        }
-        else {
-            JimDictSugarParseVarKey(interp, objPtr, &varObjPtr, &keyObjPtr);
-        }
-
-        Jim_FreeIntRep(interp, objPtr);
-        objPtr->typePtr = &dictSubstObjType;
-        objPtr->internalRep.dictSubstValue.varNameObjPtr = varObjPtr;
-        objPtr->internalRep.dictSubstValue.indexObjPtr = keyObjPtr;
-    }
-}
-
-static Jim_Obj *JimExpandDictSugar(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    Jim_Obj *resObjPtr = NULL;
-    Jim_Obj *substKeyObjPtr = NULL;
-
-    if (interp->safeexpr) {
-        return objPtr;
-    }
-
-    SetDictSubstFromAny(interp, objPtr);
-
-    if (Jim_SubstObj(interp, objPtr->internalRep.dictSubstValue.indexObjPtr,
-            &substKeyObjPtr, JIM_NONE)
-        != JIM_OK) {
-        return NULL;
-    }
-    Jim_IncrRefCount(substKeyObjPtr);
-    resObjPtr =
-        JimDictExpandArrayVariable(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr,
-        substKeyObjPtr, 0);
-    Jim_DecrRefCount(interp, substKeyObjPtr);
-
-    return resObjPtr;
-}
-
-
-static Jim_CallFrame *JimCreateCallFrame(Jim_Interp *interp, Jim_CallFrame *parent, Jim_Obj *nsObj)
-{
-    Jim_CallFrame *cf;
-
-    if (interp->freeFramesList) {
-        cf = interp->freeFramesList;
-        interp->freeFramesList = cf->next;
-
-        cf->argv = NULL;
-        cf->argc = 0;
-        cf->procArgsObjPtr = NULL;
-        cf->procBodyObjPtr = NULL;
-        cf->next = NULL;
-        cf->staticVars = NULL;
-        cf->localCommands = NULL;
-        cf->tailcallObj = NULL;
-        cf->tailcallCmd = NULL;
-    }
-    else {
-        cf = Jim_Alloc(sizeof(*cf));
-        memset(cf, 0, sizeof(*cf));
-
-        Jim_InitHashTable(&cf->vars, &JimVariablesHashTableType, interp);
-    }
-
-    cf->id = interp->callFrameEpoch++;
-    cf->parent = parent;
-    cf->level = parent ? parent->level + 1 : 0;
-    cf->nsObj = nsObj;
-    Jim_IncrRefCount(nsObj);
-
-    return cf;
-}
-
-static int JimDeleteLocalProcs(Jim_Interp *interp, Jim_Stack *localCommands)
-{
-
-    if (localCommands) {
-        Jim_Obj *cmdNameObj;
-
-        while ((cmdNameObj = Jim_StackPop(localCommands)) != NULL) {
-            Jim_HashTable *ht = &interp->commands;
-            Jim_HashEntry *he = Jim_FindHashEntry(ht, cmdNameObj);
-            if (he) {
-                Jim_Cmd *cmd = Jim_GetHashEntryVal(he);
-                if (cmd->prevCmd) {
-                    Jim_Cmd *prevCmd = cmd->prevCmd;
-                    cmd->prevCmd = NULL;
-
-
-                    JimDecrCmdRefCount(interp, cmd);
-
-
-                    Jim_SetHashVal(ht, he, prevCmd);
-                }
-                else {
-                    Jim_DeleteHashEntry(ht, cmdNameObj);
-                }
-            }
-            Jim_DecrRefCount(interp, cmdNameObj);
-        }
-        Jim_FreeStack(localCommands);
-        Jim_Free(localCommands);
-    }
-    return JIM_OK;
-}
-
-static int JimInvokeDefer(Jim_Interp *interp, int retcode)
-{
-    Jim_Obj *objPtr;
-
-
-    if (JimFindVariable(&interp->framePtr->vars, interp->defer) == NULL) {
-        return retcode;
-    }
-    objPtr = Jim_GetVariable(interp, interp->defer, JIM_NONE);
-
-    if (objPtr) {
-        int ret = JIM_OK;
-        int i;
-        int listLen = Jim_ListLength(interp, objPtr);
-        Jim_Obj *resultObjPtr;
-
-        Jim_IncrRefCount(objPtr);
-
-        resultObjPtr = Jim_GetResult(interp);
-        Jim_IncrRefCount(resultObjPtr);
-        Jim_SetEmptyResult(interp);
-
-
-        for (i = listLen; i > 0; i--) {
-
-            Jim_Obj *scriptObjPtr = Jim_ListGetIndex(interp, objPtr, i - 1);
-            ret = Jim_EvalObj(interp, scriptObjPtr);
-            if (ret != JIM_OK) {
-                break;
-            }
-        }
-
-        if (ret == JIM_OK || retcode == JIM_ERR) {
-
-            Jim_SetResult(interp, resultObjPtr);
-        }
-        else {
-            retcode = ret;
-        }
-
-        Jim_DecrRefCount(interp, resultObjPtr);
-        Jim_DecrRefCount(interp, objPtr);
-    }
-    return retcode;
-}
-
-#define JIM_FCF_FULL 0
-#define JIM_FCF_REUSE 1
-static void JimFreeCallFrame(Jim_Interp *interp, Jim_CallFrame *cf, int action)
- {
-    JimDeleteLocalProcs(interp, cf->localCommands);
-
-    if (cf->procArgsObjPtr)
-        Jim_DecrRefCount(interp, cf->procArgsObjPtr);
-    if (cf->procBodyObjPtr)
-        Jim_DecrRefCount(interp, cf->procBodyObjPtr);
-    Jim_DecrRefCount(interp, cf->nsObj);
-    if (action == JIM_FCF_FULL || cf->vars.size != JIM_HT_INITIAL_SIZE)
-        Jim_FreeHashTable(&cf->vars);
-    else {
-        Jim_ClearHashTable(&cf->vars);
-    }
-    cf->next = interp->freeFramesList;
-    interp->freeFramesList = cf;
-}
-
-
-
-int Jim_IsBigEndian(void)
-{
-    union {
-        unsigned short s;
-        unsigned char c[2];
-    } uval = {0x0102};
-
-    return uval.c[0] == 1;
-}
-
-
-Jim_Interp *Jim_CreateInterp(void)
-{
-    Jim_Interp *i = Jim_Alloc(sizeof(*i));
-
-    memset(i, 0, sizeof(*i));
-
-    i->maxCallFrameDepth = JIM_MAX_CALLFRAME_DEPTH;
-    i->maxEvalDepth = JIM_MAX_EVAL_DEPTH;
-    i->lastCollectTime = Jim_GetTimeUsec(CLOCK_MONOTONIC_RAW);
-
-    Jim_InitHashTable(&i->commands, &JimCommandsHashTableType, i);
-#ifdef JIM_REFERENCES
-    Jim_InitHashTable(&i->references, &JimReferencesHashTableType, i);
-#endif
-    Jim_InitHashTable(&i->assocData, &JimAssocDataHashTableType, i);
-    Jim_InitHashTable(&i->packages, &JimPackageHashTableType, NULL);
-    i->emptyObj = Jim_NewEmptyStringObj(i);
-    i->trueObj = Jim_NewIntObj(i, 1);
-    i->falseObj = Jim_NewIntObj(i, 0);
-    i->framePtr = i->topFramePtr = JimCreateCallFrame(i, NULL, i->emptyObj);
-    i->result = i->emptyObj;
-    i->stackTrace = Jim_NewListObj(i, NULL, 0);
-    i->unknown = Jim_NewStringObj(i, "unknown", -1);
-    i->defer = Jim_NewStringObj(i, "jim::defer", -1);
-    i->errorProc = i->emptyObj;
-    i->nullScriptObj = Jim_NewEmptyStringObj(i);
-    i->evalFrame = &i->topEvalFrame;
-    i->currentFilenameObj = Jim_NewEmptyStringObj(i);
-    Jim_IncrRefCount(i->emptyObj);
-    Jim_IncrRefCount(i->result);
-    Jim_IncrRefCount(i->stackTrace);
-    Jim_IncrRefCount(i->unknown);
-    Jim_IncrRefCount(i->defer);
-    Jim_IncrRefCount(i->nullScriptObj);
-    Jim_IncrRefCount(i->errorProc);
-    Jim_IncrRefCount(i->trueObj);
-    Jim_IncrRefCount(i->falseObj);
-    Jim_IncrRefCount(i->currentFilenameObj);
-
-
-    Jim_SetVariableStrWithStr(i, JIM_LIBPATH, TCL_LIBRARY);
-    Jim_SetVariableStrWithStr(i, JIM_INTERACTIVE, "0");
-
-    Jim_SetVariableStrWithStr(i, "tcl_platform(engine)", "Jim");
-    Jim_SetVariableStrWithStr(i, "tcl_platform(os)", TCL_PLATFORM_OS);
-    Jim_SetVariableStrWithStr(i, "tcl_platform(platform)", TCL_PLATFORM_PLATFORM);
-    Jim_SetVariableStrWithStr(i, "tcl_platform(pathSeparator)", TCL_PLATFORM_PATH_SEPARATOR);
-    Jim_SetVariableStrWithStr(i, "tcl_platform(byteOrder)", Jim_IsBigEndian() ? "bigEndian" : "littleEndian");
-    Jim_SetVariableStrWithStr(i, "tcl_platform(threaded)", "0");
-    Jim_SetVariableStrWithStr(i, "tcl_platform(bootstrap)", "0");
-    Jim_SetVariableStr(i, "tcl_platform(pointerSize)", Jim_NewIntObj(i, sizeof(void *)));
-    Jim_SetVariableStr(i, "tcl_platform(wordSize)", Jim_NewIntObj(i, sizeof(jim_wide)));
-    Jim_SetVariableStr(i, "tcl_platform(stackFormat)", Jim_NewIntObj(i, 4));
-
-    return i;
-}
-
-void Jim_FreeInterp(Jim_Interp *i)
-{
-    Jim_CallFrame *cf, *cfx;
-
-    Jim_Obj *objPtr, *nextObjPtr;
-
-    i->quitting = 1;
-
-
-    for (cf = i->framePtr; cf; cf = cfx) {
-
-        JimInvokeDefer(i, JIM_OK);
-        cfx = cf->parent;
-        JimFreeCallFrame(i, cf, JIM_FCF_FULL);
-    }
-
-
-    Jim_FreeHashTable(&i->commands);
-
-    Jim_DecrRefCount(i, i->emptyObj);
-    Jim_DecrRefCount(i, i->trueObj);
-    Jim_DecrRefCount(i, i->falseObj);
-    Jim_DecrRefCount(i, i->result);
-    Jim_DecrRefCount(i, i->stackTrace);
-    Jim_DecrRefCount(i, i->errorProc);
-    Jim_DecrRefCount(i, i->unknown);
-    Jim_DecrRefCount(i, i->defer);
-    Jim_DecrRefCount(i, i->nullScriptObj);
-    Jim_DecrRefCount(i, i->currentFilenameObj);
-
-
-    Jim_InterpIncrProcEpoch(i);
-
-#ifdef JIM_REFERENCES
-    Jim_FreeHashTable(&i->references);
-#endif
-    Jim_FreeHashTable(&i->packages);
-    Jim_Free(i->prngState);
-    Jim_FreeHashTable(&i->assocData);
-    if (i->traceCmdObj) {
-        Jim_DecrRefCount(i, i->traceCmdObj);
-    }
-
-#ifdef JIM_MAINTAINER
-    if (i->liveList != NULL) {
-        objPtr = i->liveList;
-
-        printf("\n-------------------------------------\n");
-        printf("Objects still in the free list:\n");
-        while (objPtr) {
-            const char *type = objPtr->typePtr ? objPtr->typePtr->name : "string";
-            Jim_String(objPtr);
-
-            if (objPtr->bytes && strlen(objPtr->bytes) > 20) {
-                printf("%p (%d) %-10s: '%.20s...'\n",
-                    (void *)objPtr, objPtr->refCount, type, objPtr->bytes);
-            }
-            else {
-                printf("%p (%d) %-10s: '%s'\n",
-                    (void *)objPtr, objPtr->refCount, type, objPtr->bytes ? objPtr->bytes : "(null)");
-            }
-            if (objPtr->typePtr == &sourceObjType) {
-                printf("FILE %s LINE %d\n",
-                    Jim_String(objPtr->internalRep.sourceValue.fileNameObj),
-                    objPtr->internalRep.sourceValue.lineNumber);
-            }
-            objPtr = objPtr->nextObjPtr;
-        }
-        printf("-------------------------------------\n\n");
-        JimPanic((1, "Live list non empty freeing the interpreter! Leak?"));
-    }
-#endif
-
-
-    objPtr = i->freeList;
-    while (objPtr) {
-        nextObjPtr = objPtr->nextObjPtr;
-        Jim_Free(objPtr);
-        objPtr = nextObjPtr;
-    }
-
-
-    for (cf = i->freeFramesList; cf; cf = cfx) {
-        cfx = cf->next;
-        if (cf->vars.table)
-            Jim_FreeHashTable(&cf->vars);
-        Jim_Free(cf);
-    }
-
-
-    Jim_Free(i);
-}
-
-Jim_CallFrame *Jim_GetCallFrameByLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr)
-{
-    long level;
-    const char *str;
-    Jim_CallFrame *framePtr;
-
-    if (levelObjPtr) {
-        str = Jim_String(levelObjPtr);
-        if (str[0] == '#') {
-            char *endptr;
-
-            level = jim_strtol(str + 1, &endptr);
-            if (str[1] == '\0' || endptr[0] != '\0') {
-                level = -1;
-            }
-        }
-        else {
-            if (Jim_GetLong(interp, levelObjPtr, &level) != JIM_OK || level < 0) {
-                level = -1;
-            }
-            else {
-
-                level = interp->framePtr->level - level;
-            }
-        }
-    }
-    else {
-        str = "1";
-        level = interp->framePtr->level - 1;
-    }
-
-    if (level == 0) {
-        return interp->topFramePtr;
-    }
-    if (level > 0) {
-
-        for (framePtr = interp->framePtr; framePtr; framePtr = framePtr->parent) {
-            if (framePtr->level == level) {
-                return framePtr;
-            }
-        }
-    }
-
-    Jim_SetResultFormatted(interp, "bad level \"%s\"", str);
-    return NULL;
-}
-
-static Jim_CallFrame *JimGetCallFrameByInteger(Jim_Interp *interp, long level)
-{
-    Jim_CallFrame *framePtr;
-
-    if (level == 0) {
-        return interp->framePtr;
-    }
-
-    if (level < 0) {
-
-        level = interp->framePtr->level + level;
-    }
-
-    if (level > 0) {
-
-        for (framePtr = interp->framePtr; framePtr; framePtr = framePtr->parent) {
-            if (framePtr->level == level) {
-                return framePtr;
-            }
-        }
-    }
-    return NULL;
-}
-
-static Jim_EvalFrame *JimGetEvalFrameByProcLevel(Jim_Interp *interp, int proclevel)
-{
-    Jim_EvalFrame *evalFrame;
-
-    if (proclevel == 0) {
-        return interp->evalFrame;
-    }
-
-    if (proclevel < 0) {
-
-        proclevel = interp->procLevel + proclevel;
-    }
-
-    if (proclevel >= 0) {
-
-        for (evalFrame = interp->evalFrame; evalFrame; evalFrame = evalFrame->parent) {
-            if (evalFrame->procLevel == proclevel) {
-                return evalFrame;
-            }
-        }
-    }
-    return NULL;
-}
-
-static Jim_Obj *JimProcForEvalFrame(Jim_Interp *interp, Jim_EvalFrame *frame)
-{
-    if (frame == interp->evalFrame || (frame->cmd && frame->cmd->cmdNameObj)) {
-        Jim_EvalFrame *e;
-        for (e = frame->parent; e; e = e->parent) {
-            if (e->cmd && e->cmd->isproc && e->cmd->cmdNameObj) {
-                break;
-            }
-        }
-        if (e && e->cmd && e->cmd->cmdNameObj) {
-            return e->cmd->cmdNameObj;
-        }
-    }
-    return NULL;
-}
-
-static void JimAddStackFrame(Jim_Interp *interp, Jim_EvalFrame *frame, Jim_Obj *listObj)
-{
-    Jim_Obj *procNameObj = JimProcForEvalFrame(interp, frame);
-    Jim_Obj *fileNameObj = interp->emptyObj;
-    int linenr = 1;
-
-    if (frame->scriptObj) {
-        ScriptObj *script = JimGetScript(interp, frame->scriptObj);
-        fileNameObj = script->fileNameObj;
-        linenr = script->linenr;
-    }
-
-    Jim_ListAppendElement(interp, listObj, procNameObj ? procNameObj : interp->emptyObj);
-    Jim_ListAppendElement(interp, listObj, fileNameObj);
-    Jim_ListAppendElement(interp, listObj, Jim_NewIntObj(interp, linenr));
-    Jim_ListAppendElement(interp, listObj, Jim_NewListObj(interp, frame->argv, frame->argc));
-}
-
-static void JimSetStackTrace(Jim_Interp *interp, Jim_Obj *stackTraceObj)
-{
-
-    Jim_IncrRefCount(stackTraceObj);
-    Jim_DecrRefCount(interp, interp->stackTrace);
-    interp->stackTrace = stackTraceObj;
-    interp->errorFlag = 1;
-}
-
-static void JimSetErrorStack(Jim_Interp *interp, ScriptObj *script)
-{
-    if (!interp->errorFlag) {
-        int i;
-        Jim_Obj *stackTrace = Jim_NewListObj(interp, NULL, 0);
-
-        if (interp->procLevel == 0 && script) {
-            Jim_ListAppendElement(interp, stackTrace, interp->emptyObj);
-            Jim_ListAppendElement(interp, stackTrace, script->fileNameObj);
-            Jim_ListAppendElement(interp, stackTrace, Jim_NewIntObj(interp, script->linenr));
-            Jim_ListAppendElement(interp, stackTrace, interp->emptyObj);
-        }
-        else {
-            for (i = 0; i <= interp->procLevel; i++) {
-                Jim_EvalFrame *frame = JimGetEvalFrameByProcLevel(interp, -i);
-                if (frame) {
-                    JimAddStackFrame(interp, frame, stackTrace);
-                }
-            }
-        }
-        JimSetStackTrace(interp, stackTrace);
-    }
-}
-
-int Jim_SetAssocData(Jim_Interp *interp, const char *key, Jim_InterpDeleteProc * delProc,
-    void *data)
-{
-    AssocDataValue *assocEntryPtr = (AssocDataValue *) Jim_Alloc(sizeof(AssocDataValue));
-
-    assocEntryPtr->delProc = delProc;
-    assocEntryPtr->data = data;
-    return Jim_AddHashEntry(&interp->assocData, key, assocEntryPtr);
-}
-
-void *Jim_GetAssocData(Jim_Interp *interp, const char *key)
-{
-    Jim_HashEntry *entryPtr = Jim_FindHashEntry(&interp->assocData, key);
-
-    if (entryPtr != NULL) {
-        AssocDataValue *assocEntryPtr = Jim_GetHashEntryVal(entryPtr);
-        return assocEntryPtr->data;
-    }
-    return NULL;
-}
-
-int Jim_DeleteAssocData(Jim_Interp *interp, const char *key)
-{
-    return Jim_DeleteHashEntry(&interp->assocData, key);
-}
-
-int Jim_GetExitCode(Jim_Interp *interp)
-{
-    return interp->exitCode;
-}
-
-static void UpdateStringOfInt(struct Jim_Obj *objPtr);
-static int SetIntFromAny(Jim_Interp *interp, Jim_Obj *objPtr, int flags);
-
-static const Jim_ObjType intObjType = {
-    "int",
-    NULL,
-    NULL,
-    UpdateStringOfInt,
-    JIM_TYPE_NONE,
-};
-
-static const Jim_ObjType coercedDoubleObjType = {
-    "coerced-double",
-    NULL,
-    NULL,
-    UpdateStringOfInt,
-    JIM_TYPE_NONE,
-};
-
-
-static void UpdateStringOfInt(struct Jim_Obj *objPtr)
-{
-    char buf[JIM_INTEGER_SPACE + 1];
-    jim_wide wideValue = JimWideValue(objPtr);
-    int pos = 0;
-
-    if (wideValue == 0) {
-        buf[pos++] = '0';
-    }
-    else {
-        char tmp[JIM_INTEGER_SPACE];
-        int num = 0;
-        int i;
-
-        if (wideValue < 0) {
-            buf[pos++] = '-';
-            i = wideValue % 10;
-            tmp[num++] = (i > 0) ? (10 - i) : -i;
-            wideValue /= -10;
-        }
-
-        while (wideValue) {
-            tmp[num++] = wideValue % 10;
-            wideValue /= 10;
-        }
-
-        for (i = 0; i < num; i++) {
-            buf[pos++] = '0' + tmp[num - i - 1];
-        }
-    }
-    buf[pos] = 0;
-
-    JimSetStringBytes(objPtr, buf);
-}
-
-static int SetIntFromAny(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
-{
-    jim_wide wideValue;
-    const char *str;
-
-    if (objPtr->typePtr == &coercedDoubleObjType) {
-
-        objPtr->typePtr = &intObjType;
-        return JIM_OK;
-    }
-
-
-    str = Jim_String(objPtr);
-
-    if (Jim_StringToWide(str, &wideValue, 0) != JIM_OK) {
-        if (flags & JIM_ERRMSG) {
-            Jim_SetResultFormatted(interp, "expected integer but got \"%#s\"", objPtr);
-        }
-        return JIM_ERR;
-    }
-    if ((wideValue == JIM_WIDE_MIN || wideValue == JIM_WIDE_MAX) && errno == ERANGE) {
-        Jim_SetResultString(interp, "Integer value too big to be represented", -1);
-        return JIM_ERR;
-    }
-
-    Jim_FreeIntRep(interp, objPtr);
-    objPtr->typePtr = &intObjType;
-    objPtr->internalRep.wideValue = wideValue;
-    return JIM_OK;
-}
-
-#ifdef JIM_OPTIMIZATION
-static int JimIsWide(Jim_Obj *objPtr)
-{
-    return objPtr->typePtr == &intObjType;
-}
-#endif
-
-int Jim_GetWide(Jim_Interp *interp, Jim_Obj *objPtr, jim_wide * widePtr)
-{
-    if (objPtr->typePtr != &intObjType && SetIntFromAny(interp, objPtr, JIM_ERRMSG) == JIM_ERR)
-        return JIM_ERR;
-    *widePtr = JimWideValue(objPtr);
-    return JIM_OK;
-}
-
-int Jim_GetWideExpr(Jim_Interp *interp, Jim_Obj *objPtr, jim_wide * widePtr)
-{
-    int ret = JIM_OK;
-
-    if (objPtr->typePtr == &sourceObjType || objPtr->typePtr == NULL) {
-        SetIntFromAny(interp, objPtr, 0);
-    }
-    if (objPtr->typePtr == &intObjType) {
-        *widePtr = JimWideValue(objPtr);
-    }
-    else {
-        JimPanic((interp->safeexpr, "interp->safeexpr is set"));
-        interp->safeexpr++;
-        ret = Jim_EvalExpression(interp, objPtr);
-        interp->safeexpr--;
-
-        if (ret == JIM_OK) {
-            ret = Jim_GetWide(interp, Jim_GetResult(interp), widePtr);
-        }
-        if (ret != JIM_OK) {
-            Jim_SetResultFormatted(interp, "expected integer expression but got \"%#s\"", objPtr);
-        }
-    }
-    return ret;
-}
-
-
-static int JimGetWideNoErr(Jim_Interp *interp, Jim_Obj *objPtr, jim_wide * widePtr)
-{
-    if (objPtr->typePtr != &intObjType && SetIntFromAny(interp, objPtr, JIM_NONE) == JIM_ERR)
-        return JIM_ERR;
-    *widePtr = JimWideValue(objPtr);
-    return JIM_OK;
-}
-
-int Jim_GetLong(Jim_Interp *interp, Jim_Obj *objPtr, long *longPtr)
-{
-    jim_wide wideValue;
-    int retval;
-
-    retval = Jim_GetWide(interp, objPtr, &wideValue);
-    if (retval == JIM_OK) {
-        *longPtr = (long)wideValue;
-        return JIM_OK;
-    }
-    return JIM_ERR;
-}
-
-Jim_Obj *Jim_NewIntObj(Jim_Interp *interp, jim_wide wideValue)
-{
-    Jim_Obj *objPtr;
-
-    objPtr = Jim_NewObj(interp);
-    objPtr->typePtr = &intObjType;
-    objPtr->bytes = NULL;
-    objPtr->internalRep.wideValue = wideValue;
-    return objPtr;
-}
-
-#define JIM_DOUBLE_SPACE 30
-
-static void UpdateStringOfDouble(struct Jim_Obj *objPtr);
-static int SetDoubleFromAny(Jim_Interp *interp, Jim_Obj *objPtr);
-
-static const Jim_ObjType doubleObjType = {
-    "double",
-    NULL,
-    NULL,
-    UpdateStringOfDouble,
-    JIM_TYPE_NONE,
-};
-
-#if !HAVE_DECL_ISNAN
-#undef isnan
-#define isnan(X) ((X) != (X))
-#endif
-#if !HAVE_DECL_ISINF
-#undef isinf
-#define isinf(X) (1.0 / (X) == 0.0)
-#endif
-
-static void UpdateStringOfDouble(struct Jim_Obj *objPtr)
-{
-    double value = objPtr->internalRep.doubleValue;
-
-    if (isnan(value)) {
-        JimSetStringBytes(objPtr, "NaN");
-        return;
-    }
-    if (isinf(value)) {
-        if (value < 0) {
-            JimSetStringBytes(objPtr, "-Inf");
-        }
-        else {
-            JimSetStringBytes(objPtr, "Inf");
-        }
-        return;
-    }
-    {
-        char buf[JIM_DOUBLE_SPACE + 1];
-        int i;
-        int len = sprintf(buf, "%.12g", value);
-
-
-        for (i = 0; i < len; i++) {
-            if (buf[i] == '.' || buf[i] == 'e') {
-#if defined(JIM_SPRINTF_DOUBLE_NEEDS_FIX)
-                char *e = strchr(buf, 'e');
-                if (e && (e[1] == '-' || e[1] == '+') && e[2] == '0') {
-
-                    e += 2;
-                    memmove(e, e + 1, len - (e - buf));
-                }
-#endif
-                break;
-            }
-        }
-        if (buf[i] == '\0') {
-            buf[i++] = '.';
-            buf[i++] = '0';
-            buf[i] = '\0';
-        }
-        JimSetStringBytes(objPtr, buf);
-    }
-}
-
-static int SetDoubleFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    double doubleValue;
-    jim_wide wideValue;
-    const char *str;
-
-#ifdef HAVE_LONG_LONG
-
-#define MIN_INT_IN_DOUBLE -(1LL << 53)
-#define MAX_INT_IN_DOUBLE -(MIN_INT_IN_DOUBLE + 1)
-
-    if (objPtr->typePtr == &intObjType
-        && JimWideValue(objPtr) >= MIN_INT_IN_DOUBLE
-        && JimWideValue(objPtr) <= MAX_INT_IN_DOUBLE) {
-
-
-        objPtr->typePtr = &coercedDoubleObjType;
-        return JIM_OK;
-    }
-#endif
-    str = Jim_String(objPtr);
-
-    if (Jim_StringToWide(str, &wideValue, 10) == JIM_OK) {
-
-        Jim_FreeIntRep(interp, objPtr);
-        objPtr->typePtr = &coercedDoubleObjType;
-        objPtr->internalRep.wideValue = wideValue;
-        return JIM_OK;
-    }
-    else {
-
-        if (Jim_StringToDouble(str, &doubleValue) != JIM_OK) {
-            Jim_SetResultFormatted(interp, "expected floating-point number but got \"%#s\"", objPtr);
-            return JIM_ERR;
-        }
-
-        Jim_FreeIntRep(interp, objPtr);
-    }
-    objPtr->typePtr = &doubleObjType;
-    objPtr->internalRep.doubleValue = doubleValue;
-    return JIM_OK;
-}
-
-int Jim_GetDouble(Jim_Interp *interp, Jim_Obj *objPtr, double *doublePtr)
-{
-    if (objPtr->typePtr == &coercedDoubleObjType) {
-        *doublePtr = JimWideValue(objPtr);
-        return JIM_OK;
-    }
-    if (objPtr->typePtr != &doubleObjType && SetDoubleFromAny(interp, objPtr) == JIM_ERR)
-        return JIM_ERR;
-
-    if (objPtr->typePtr == &coercedDoubleObjType) {
-        *doublePtr = JimWideValue(objPtr);
-    }
-    else {
-        *doublePtr = objPtr->internalRep.doubleValue;
-    }
-    return JIM_OK;
-}
-
-Jim_Obj *Jim_NewDoubleObj(Jim_Interp *interp, double doubleValue)
-{
-    Jim_Obj *objPtr;
-
-    objPtr = Jim_NewObj(interp);
-    objPtr->typePtr = &doubleObjType;
-    objPtr->bytes = NULL;
-    objPtr->internalRep.doubleValue = doubleValue;
-    return objPtr;
-}
-
-static int SetBooleanFromAny(Jim_Interp *interp, Jim_Obj *objPtr, int flags);
-
-int Jim_GetBoolean(Jim_Interp *interp, Jim_Obj *objPtr, int * booleanPtr)
-{
-    if (objPtr->typePtr != &intObjType && SetBooleanFromAny(interp, objPtr, JIM_ERRMSG) == JIM_ERR)
-        return JIM_ERR;
-    *booleanPtr = (int) JimWideValue(objPtr);
-    return JIM_OK;
-}
-
-static const char * const jim_true_false_strings[8] = {
-    "1", "true", "yes", "on",
-    "0", "false", "no", "off"
-};
-
-static const int jim_true_false_lens[8] = {
-    1, 4, 3, 2,
-    1, 5, 2, 3,
-};
-
-static int SetBooleanFromAny(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
-{
-    int index = Jim_FindByName(Jim_String(objPtr), jim_true_false_strings,
-        sizeof(jim_true_false_strings) / sizeof(*jim_true_false_strings));
-    if (index < 0) {
-        if (flags & JIM_ERRMSG) {
-            Jim_SetResultFormatted(interp, "expected boolean but got \"%#s\"", objPtr);
-        }
-        return JIM_ERR;
-    }
-
-
-    Jim_FreeIntRep(interp, objPtr);
-    objPtr->typePtr = &intObjType;
-
-    objPtr->internalRep.wideValue = index < 4 ? 1 : 0;
-    return JIM_OK;
-}
-
-static void ListInsertElements(Jim_Obj *listPtr, int idx, int elemc, Jim_Obj *const *elemVec);
-static void ListAppendElement(Jim_Obj *listPtr, Jim_Obj *objPtr);
-static void FreeListInternalRep(Jim_Interp *interp, Jim_Obj *objPtr);
-static void DupListInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
-static void UpdateStringOfList(struct Jim_Obj *objPtr);
-static int SetListFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
-
-static const Jim_ObjType listObjType = {
-    "list",
-    FreeListInternalRep,
-    DupListInternalRep,
-    UpdateStringOfList,
-    JIM_TYPE_NONE,
-};
-
-void FreeListInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    int i;
-
-    for (i = 0; i < objPtr->internalRep.listValue.len; i++) {
-        Jim_DecrRefCount(interp, objPtr->internalRep.listValue.ele[i]);
-    }
-    Jim_Free(objPtr->internalRep.listValue.ele);
-}
-
-void DupListInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
-{
-    int i;
-
-    JIM_NOTUSED(interp);
-
-    dupPtr->internalRep.listValue.len = srcPtr->internalRep.listValue.len;
-    dupPtr->internalRep.listValue.maxLen = srcPtr->internalRep.listValue.maxLen;
-    dupPtr->internalRep.listValue.ele =
-        Jim_Alloc(sizeof(Jim_Obj *) * srcPtr->internalRep.listValue.maxLen);
-    memcpy(dupPtr->internalRep.listValue.ele, srcPtr->internalRep.listValue.ele,
-        sizeof(Jim_Obj *) * srcPtr->internalRep.listValue.len);
-    for (i = 0; i < dupPtr->internalRep.listValue.len; i++) {
-        Jim_IncrRefCount(dupPtr->internalRep.listValue.ele[i]);
-    }
-    dupPtr->typePtr = &listObjType;
-}
-
-#define JIM_ELESTR_SIMPLE 0
-#define JIM_ELESTR_BRACE 1
-#define JIM_ELESTR_QUOTE 2
-static unsigned char ListElementQuotingType(const char *s, int len)
-{
-    int i, level, blevel, trySimple = 1;
-
-
-    if (len == 0)
-        return JIM_ELESTR_BRACE;
-    if (s[0] == '"' || s[0] == '{') {
-        trySimple = 0;
-        goto testbrace;
-    }
-    for (i = 0; i < len; i++) {
-        switch (s[i]) {
-            case ' ':
-            case '$':
-            case '"':
-            case '[':
-            case ']':
-            case ';':
-            case '\\':
-            case '\r':
-            case '\n':
-            case '\t':
-            case '\f':
-            case '\v':
-                trySimple = 0;
-
-            case '{':
-            case '}':
-                goto testbrace;
-        }
-    }
-    return JIM_ELESTR_SIMPLE;
-
-  testbrace:
-
-    if (s[len - 1] == '\\')
-        return JIM_ELESTR_QUOTE;
-    level = 0;
-    blevel = 0;
-    for (i = 0; i < len; i++) {
-        switch (s[i]) {
-            case '{':
-                level++;
-                break;
-            case '}':
-                level--;
-                if (level < 0)
-                    return JIM_ELESTR_QUOTE;
-                break;
-            case '[':
-                blevel++;
-                break;
-            case ']':
-                blevel--;
-                break;
-            case '\\':
-                if (s[i + 1] == '\n')
-                    return JIM_ELESTR_QUOTE;
-                else if (s[i + 1] != '\0')
-                    i++;
-                break;
-        }
-    }
-    if (blevel < 0) {
-        return JIM_ELESTR_QUOTE;
-    }
-
-    if (level == 0) {
-        if (!trySimple)
-            return JIM_ELESTR_BRACE;
-        for (i = 0; i < len; i++) {
-            switch (s[i]) {
-                case ' ':
-                case '$':
-                case '"':
-                case '[':
-                case ']':
-                case ';':
-                case '\\':
-                case '\r':
-                case '\n':
-                case '\t':
-                case '\f':
-                case '\v':
-                    return JIM_ELESTR_BRACE;
-                    break;
-            }
-        }
-        return JIM_ELESTR_SIMPLE;
-    }
-    return JIM_ELESTR_QUOTE;
-}
-
-static int BackslashQuoteString(const char *s, int len, char *q)
-{
-    char *p = q;
-
-    while (len--) {
-        switch (*s) {
-            case ' ':
-            case '$':
-            case '"':
-            case '[':
-            case ']':
-            case '{':
-            case '}':
-            case ';':
-            case '\\':
-                *p++ = '\\';
-                *p++ = *s++;
-                break;
-            case '\n':
-                *p++ = '\\';
-                *p++ = 'n';
-                s++;
-                break;
-            case '\r':
-                *p++ = '\\';
-                *p++ = 'r';
-                s++;
-                break;
-            case '\t':
-                *p++ = '\\';
-                *p++ = 't';
-                s++;
-                break;
-            case '\f':
-                *p++ = '\\';
-                *p++ = 'f';
-                s++;
-                break;
-            case '\v':
-                *p++ = '\\';
-                *p++ = 'v';
-                s++;
-                break;
-            default:
-                *p++ = *s++;
-                break;
-        }
-    }
-    *p = '\0';
-
-    return p - q;
-}
-
-static void JimMakeListStringRep(Jim_Obj *objPtr, Jim_Obj **objv, int objc)
-{
-    #define STATIC_QUOTING_LEN 32
-    int i, bufLen, realLength;
-    const char *strRep;
-    char *p;
-    unsigned char *quotingType, staticQuoting[STATIC_QUOTING_LEN];
-
-
-    if (objc > STATIC_QUOTING_LEN) {
-        quotingType = Jim_Alloc(objc);
-    }
-    else {
-        quotingType = staticQuoting;
-    }
-    bufLen = 0;
-    for (i = 0; i < objc; i++) {
-        int len;
-
-        strRep = Jim_GetString(objv[i], &len);
-        quotingType[i] = ListElementQuotingType(strRep, len);
-        switch (quotingType[i]) {
-            case JIM_ELESTR_SIMPLE:
-                if (i != 0 || strRep[0] != '#') {
-                    bufLen += len;
-                    break;
-                }
-
-                quotingType[i] = JIM_ELESTR_BRACE;
-
-            case JIM_ELESTR_BRACE:
-                bufLen += len + 2;
-                break;
-            case JIM_ELESTR_QUOTE:
-                bufLen += len * 2;
-                break;
-        }
-        bufLen++;
-    }
-    bufLen++;
-
-
-    p = objPtr->bytes = Jim_Alloc(bufLen + 1);
-    realLength = 0;
-    for (i = 0; i < objc; i++) {
-        int len, qlen;
-
-        strRep = Jim_GetString(objv[i], &len);
-
-        switch (quotingType[i]) {
-            case JIM_ELESTR_SIMPLE:
-                memcpy(p, strRep, len);
-                p += len;
-                realLength += len;
-                break;
-            case JIM_ELESTR_BRACE:
-                *p++ = '{';
-                memcpy(p, strRep, len);
-                p += len;
-                *p++ = '}';
-                realLength += len + 2;
-                break;
-            case JIM_ELESTR_QUOTE:
-                if (i == 0 && strRep[0] == '#') {
-                    *p++ = '\\';
-                    realLength++;
-                }
-                qlen = BackslashQuoteString(strRep, len, p);
-                p += qlen;
-                realLength += qlen;
-                break;
-        }
-
-        if (i + 1 != objc) {
-            *p++ = ' ';
-            realLength++;
-        }
-    }
-    *p = '\0';
-    objPtr->length = realLength;
-
-    if (quotingType != staticQuoting) {
-        Jim_Free(quotingType);
-    }
-}
-
-static void UpdateStringOfList(struct Jim_Obj *objPtr)
-{
-    JimMakeListStringRep(objPtr, objPtr->internalRep.listValue.ele, objPtr->internalRep.listValue.len);
-}
-
-static int SetListFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
-{
-    struct JimParserCtx parser;
-    const char *str;
-    int strLen;
-    Jim_Obj *fileNameObj;
-    int linenr;
-
-    if (objPtr->typePtr == &listObjType) {
-        return JIM_OK;
-    }
-
-
-    if (Jim_IsDict(objPtr) && objPtr->bytes == NULL) {
-        Jim_Dict *dict = objPtr->internalRep.dictValue;
-
-
-        objPtr->typePtr = &listObjType;
-        objPtr->internalRep.listValue.len = dict->len;
-        objPtr->internalRep.listValue.maxLen = dict->maxLen;
-        objPtr->internalRep.listValue.ele = dict->table;
-
-
-        Jim_Free(dict->ht);
-
-
-        Jim_Free(dict);
-        return JIM_OK;
-    }
-
-
-    fileNameObj = Jim_GetSourceInfo(interp, objPtr, &linenr);
-    Jim_IncrRefCount(fileNameObj);
-
-
-    str = Jim_GetString(objPtr, &strLen);
-
-    Jim_FreeIntRep(interp, objPtr);
-    objPtr->typePtr = &listObjType;
-    objPtr->internalRep.listValue.len = 0;
-    objPtr->internalRep.listValue.maxLen = 0;
-    objPtr->internalRep.listValue.ele = NULL;
-
-
-    if (strLen) {
-        JimParserInit(&parser, str, strLen, linenr);
-        while (!parser.eof) {
-            Jim_Obj *elementPtr;
-
-            JimParseList(&parser);
-            if (parser.tt != JIM_TT_STR && parser.tt != JIM_TT_ESC)
-                continue;
-            elementPtr = JimParserGetTokenObj(interp, &parser);
-            Jim_SetSourceInfo(interp, elementPtr, fileNameObj, parser.tline);
-            ListAppendElement(objPtr, elementPtr);
-        }
-    }
-    Jim_DecrRefCount(interp, fileNameObj);
-    return JIM_OK;
-}
-
-Jim_Obj *Jim_NewListObj(Jim_Interp *interp, Jim_Obj *const *elements, int len)
-{
-    Jim_Obj *objPtr;
-
-    objPtr = Jim_NewObj(interp);
-    objPtr->typePtr = &listObjType;
-    objPtr->bytes = NULL;
-    objPtr->internalRep.listValue.ele = NULL;
-    objPtr->internalRep.listValue.len = 0;
-    objPtr->internalRep.listValue.maxLen = 0;
-
-    if (len) {
-        ListInsertElements(objPtr, 0, len, elements);
-    }
-
-    return objPtr;
-}
-
-static void JimListGetElements(Jim_Interp *interp, Jim_Obj *listObj, int *listLen,
-    Jim_Obj ***listVec)
-{
-    *listLen = Jim_ListLength(interp, listObj);
-    *listVec = listObj->internalRep.listValue.ele;
-}
-
-
-static int JimSign(jim_wide w)
-{
-    if (w == 0) {
-        return 0;
-    }
-    else if (w < 0) {
-        return -1;
-    }
-    return 1;
-}
-
-
-struct lsort_info {
-    jmp_buf jmpbuf;
-    Jim_Obj *command;
-    Jim_Interp *interp;
-    enum {
-        JIM_LSORT_ASCII,
-        JIM_LSORT_NOCASE,
-        JIM_LSORT_INTEGER,
-        JIM_LSORT_REAL,
-        JIM_LSORT_COMMAND,
-        JIM_LSORT_DICT
-    } type;
-    int order;
-    Jim_Obj **indexv;
-    int indexc;
-    int unique;
-    int (*subfn)(Jim_Obj **, Jim_Obj **);
-};
-
-static struct lsort_info *sort_info;
-
-static int ListSortIndexHelper(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
-{
-    Jim_Obj *lObj, *rObj;
-
-    if (Jim_ListIndices(sort_info->interp, *lhsObj, sort_info->indexv, sort_info->indexc, &lObj, JIM_ERRMSG) != JIM_OK ||
-        Jim_ListIndices(sort_info->interp, *rhsObj, sort_info->indexv, sort_info->indexc, &rObj, JIM_ERRMSG) != JIM_OK) {
-        longjmp(sort_info->jmpbuf, JIM_ERR);
-    }
-    return sort_info->subfn(&lObj, &rObj);
-}
-
-
-static int ListSortString(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
-{
-    return Jim_StringCompareObj(sort_info->interp, *lhsObj, *rhsObj, 0) * sort_info->order;
-}
-
-static int ListSortStringNoCase(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
-{
-    return Jim_StringCompareObj(sort_info->interp, *lhsObj, *rhsObj, 1) * sort_info->order;
-}
-
-static int ListSortDict(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
-{
-
-    const char *left = Jim_String(*lhsObj);
-    const char *right = Jim_String(*rhsObj);
-
-    while (1) {
-        if (isdigit(UCHAR(*left)) && isdigit(UCHAR(*right))) {
-
-            jim_wide lint, rint;
-            char *lend, *rend;
-            lint = jim_strtoull(left, &lend);
-            rint = jim_strtoull(right, &rend);
-            if (lint != rint) {
-                return JimSign(lint - rint) * sort_info->order;
-            }
-            if (lend -left != rend - right) {
-                return JimSign((lend - left) - (rend - right)) * sort_info->order;
-            }
-            left = lend;
-            right = rend;
-        }
-        else {
-            int cl, cr;
-            left += utf8_tounicode_case(left, &cl, 1);
-            right += utf8_tounicode_case(right, &cr, 1);
-            if (cl != cr) {
-                return JimSign(cl - cr) * sort_info->order;
-            }
-            if (cl == 0) {
-
-                return Jim_StringCompareObj(sort_info->interp, *lhsObj, *rhsObj, 0) * sort_info->order;
-            }
-        }
-    }
-}
-
-static int ListSortInteger(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
-{
-    jim_wide lhs = 0, rhs = 0;
-
-    if (Jim_GetWide(sort_info->interp, *lhsObj, &lhs) != JIM_OK ||
-        Jim_GetWide(sort_info->interp, *rhsObj, &rhs) != JIM_OK) {
-        longjmp(sort_info->jmpbuf, JIM_ERR);
-    }
-
-    return JimSign(lhs - rhs) * sort_info->order;
-}
-
-static int ListSortReal(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
-{
-    double lhs = 0, rhs = 0;
-
-    if (Jim_GetDouble(sort_info->interp, *lhsObj, &lhs) != JIM_OK ||
-        Jim_GetDouble(sort_info->interp, *rhsObj, &rhs) != JIM_OK) {
-        longjmp(sort_info->jmpbuf, JIM_ERR);
-    }
-    if (lhs == rhs) {
-        return 0;
-    }
-    if (lhs > rhs) {
-        return sort_info->order;
-    }
-    return -sort_info->order;
-}
-
-static int ListSortCommand(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
-{
-    Jim_Obj *compare_script;
-    int rc;
-
-    jim_wide ret = 0;
-
-
-    compare_script = Jim_DuplicateObj(sort_info->interp, sort_info->command);
-    Jim_ListAppendElement(sort_info->interp, compare_script, *lhsObj);
-    Jim_ListAppendElement(sort_info->interp, compare_script, *rhsObj);
-
-    rc = Jim_EvalObj(sort_info->interp, compare_script);
-
-    if (rc != JIM_OK || Jim_GetWide(sort_info->interp, Jim_GetResult(sort_info->interp), &ret) != JIM_OK) {
-        longjmp(sort_info->jmpbuf, rc);
-    }
-
-    return JimSign(ret) * sort_info->order;
-}
-
-static void ListRemoveDuplicates(Jim_Obj *listObjPtr, int (*comp)(Jim_Obj **lhs, Jim_Obj **rhs))
-{
-    int src;
-    int dst = 0;
-    Jim_Obj **ele = listObjPtr->internalRep.listValue.ele;
-
-    for (src = 1; src < listObjPtr->internalRep.listValue.len; src++) {
-        if (comp(&ele[dst], &ele[src]) == 0) {
-
-            Jim_DecrRefCount(sort_info->interp, ele[dst]);
-        }
-        else {
-
-            dst++;
-        }
-        ele[dst] = ele[src];
-    }
-
-
-    dst++;
-    if (dst < listObjPtr->internalRep.listValue.len) {
-        ele[dst] = ele[src];
-    }
-
-
-    listObjPtr->internalRep.listValue.len = dst;
-}
-
-
-static int ListSortElements(Jim_Interp *interp, Jim_Obj *listObjPtr, struct lsort_info *info)
-{
-    struct lsort_info *prev_info;
-
-    typedef int (qsort_comparator) (const void *, const void *);
-    int (*fn) (Jim_Obj **, Jim_Obj **);
-    Jim_Obj **vector;
-    int len;
-    int rc;
-
-    JimPanic((Jim_IsShared(listObjPtr), "ListSortElements called with shared object"));
-    SetListFromAny(interp, listObjPtr);
-
-
-    prev_info = sort_info;
-    sort_info = info;
-
-    vector = listObjPtr->internalRep.listValue.ele;
-    len = listObjPtr->internalRep.listValue.len;
-    switch (info->type) {
-        case JIM_LSORT_ASCII:
-            fn = ListSortString;
-            break;
-        case JIM_LSORT_NOCASE:
-            fn = ListSortStringNoCase;
-            break;
-        case JIM_LSORT_INTEGER:
-            fn = ListSortInteger;
-            break;
-        case JIM_LSORT_REAL:
-            fn = ListSortReal;
-            break;
-        case JIM_LSORT_COMMAND:
-            fn = ListSortCommand;
-            break;
-        case JIM_LSORT_DICT:
-            fn = ListSortDict;
-            break;
-        default:
-            fn = NULL;
-            JimPanic((1, "ListSort called with invalid sort type"));
-            return -1;
-    }
-
-    if (info->indexc) {
-
-        info->subfn = fn;
-        fn = ListSortIndexHelper;
-    }
-
-    if ((rc = setjmp(info->jmpbuf)) == 0) {
-        qsort(vector, len, sizeof(Jim_Obj *), (qsort_comparator *) fn);
-
-        if (info->unique && len > 1) {
-            ListRemoveDuplicates(listObjPtr, fn);
-        }
-
-        Jim_InvalidateStringRep(listObjPtr);
-    }
-    sort_info = prev_info;
-
-    return rc;
-}
-
-
-static void ListEnsureLength(Jim_Obj *listPtr, int idx)
-{
-    assert(idx >= 0);
-    if (idx >= listPtr->internalRep.listValue.maxLen) {
-        if (idx < 4) {
-
-            idx = 4;
-        }
-        listPtr->internalRep.listValue.ele = Jim_Realloc(listPtr->internalRep.listValue.ele,
-            sizeof(Jim_Obj *) * idx);
-
-        listPtr->internalRep.listValue.maxLen = idx;
-    }
-}
-
-static void ListInsertElements(Jim_Obj *listPtr, int idx, int elemc, Jim_Obj *const *elemVec)
-{
-    int currentLen = listPtr->internalRep.listValue.len;
-    int requiredLen = currentLen + elemc;
-    int i;
-    Jim_Obj **point;
-
-    if (elemc == 0) {
-
-        return;
-    }
-
-    if (requiredLen > listPtr->internalRep.listValue.maxLen) {
-        if (currentLen) {
-
-            requiredLen *= 2;
-        }
-        ListEnsureLength(listPtr, requiredLen);
-    }
-    if (idx < 0) {
-        idx = currentLen;
-    }
-    point = listPtr->internalRep.listValue.ele + idx;
-    memmove(point + elemc, point, (currentLen - idx) * sizeof(Jim_Obj *));
-    for (i = 0; i < elemc; ++i) {
-        point[i] = elemVec[i];
-        Jim_IncrRefCount(point[i]);
-    }
-    listPtr->internalRep.listValue.len += elemc;
-}
-
-static void ListAppendElement(Jim_Obj *listPtr, Jim_Obj *objPtr)
-{
-    ListInsertElements(listPtr, -1, 1, &objPtr);
-}
-
-static void ListAppendList(Jim_Obj *listPtr, Jim_Obj *appendListPtr)
-{
-    ListInsertElements(listPtr, -1,
-        appendListPtr->internalRep.listValue.len, appendListPtr->internalRep.listValue.ele);
-}
-
-void Jim_ListAppendElement(Jim_Interp *interp, Jim_Obj *listPtr, Jim_Obj *objPtr)
-{
-    JimPanic((Jim_IsShared(listPtr), "Jim_ListAppendElement called with shared object"));
-    SetListFromAny(interp, listPtr);
-    Jim_InvalidateStringRep(listPtr);
-    ListAppendElement(listPtr, objPtr);
-}
-
-void Jim_ListAppendList(Jim_Interp *interp, Jim_Obj *listPtr, Jim_Obj *appendListPtr)
-{
-    JimPanic((Jim_IsShared(listPtr), "Jim_ListAppendList called with shared object"));
-    SetListFromAny(interp, listPtr);
-    SetListFromAny(interp, appendListPtr);
-    Jim_InvalidateStringRep(listPtr);
-    ListAppendList(listPtr, appendListPtr);
-}
-
-int Jim_ListLength(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    SetListFromAny(interp, objPtr);
-    return objPtr->internalRep.listValue.len;
-}
-
-void Jim_ListInsertElements(Jim_Interp *interp, Jim_Obj *listPtr, int idx,
-    int objc, Jim_Obj *const *objVec)
-{
-    JimPanic((Jim_IsShared(listPtr), "Jim_ListInsertElement called with shared object"));
-    SetListFromAny(interp, listPtr);
-    if (idx >= 0 && idx > listPtr->internalRep.listValue.len)
-        idx = listPtr->internalRep.listValue.len;
-    else if (idx < 0)
-        idx = 0;
-    Jim_InvalidateStringRep(listPtr);
-    ListInsertElements(listPtr, idx, objc, objVec);
-}
-
-Jim_Obj *Jim_ListGetIndex(Jim_Interp *interp, Jim_Obj *listPtr, int idx)
-{
-    SetListFromAny(interp, listPtr);
-    if ((idx >= 0 && idx >= listPtr->internalRep.listValue.len) ||
-        (idx < 0 && (-idx - 1) >= listPtr->internalRep.listValue.len)) {
-        return NULL;
-    }
-    if (idx < 0)
-        idx = listPtr->internalRep.listValue.len + idx;
-    return listPtr->internalRep.listValue.ele[idx];
-}
-
-int Jim_ListIndex(Jim_Interp *interp, Jim_Obj *listPtr, int idx, Jim_Obj **objPtrPtr, int flags)
-{
-    *objPtrPtr = Jim_ListGetIndex(interp, listPtr, idx);
-    if (*objPtrPtr == NULL) {
-        if (flags & JIM_ERRMSG) {
-            Jim_SetResultString(interp, "list index out of range", -1);
-        }
-        return JIM_ERR;
-    }
-    return JIM_OK;
-}
-
-static int Jim_ListIndices(Jim_Interp *interp, Jim_Obj *listPtr,
-    Jim_Obj *const *indexv, int indexc, Jim_Obj **resultObj, int flags)
-{
-    int i;
-    int static_idxes[5];
-    int *idxes = static_idxes;
-    int ret = JIM_OK;
-
-    if (indexc > sizeof(static_idxes) / sizeof(*static_idxes)) {
-        idxes = Jim_Alloc(indexc * sizeof(*idxes));
-    }
-
-    for (i = 0; i < indexc; i++) {
-        ret = Jim_GetIndex(interp, indexv[i], &idxes[i]);
-        if (ret != JIM_OK) {
-            goto err;
-        }
-    }
-
-    for (i = 0; i < indexc; i++) {
-        Jim_Obj *objPtr = Jim_ListGetIndex(interp, listPtr, idxes[i]);
-        if (!objPtr) {
-            if (flags & JIM_ERRMSG) {
-                if (idxes[i] < 0 || idxes[i] > Jim_ListLength(interp, listPtr)) {
-                    Jim_SetResultFormatted(interp, "index \"%#s\" out of range", indexv[i]);
-                }
-                else {
-                    Jim_SetResultFormatted(interp, "element %#s missing from sublist \"%#s\"", indexv[i], listPtr);
-                }
-            }
-            return -1;
-        }
-        listPtr = objPtr;
-    }
-    *resultObj = listPtr;
-err:
-    if (idxes != static_idxes)
-        Jim_Free(idxes);
-    return ret;
-}
-
-static int ListSetIndex(Jim_Interp *interp, Jim_Obj *listPtr, int idx,
-    Jim_Obj *newObjPtr, int flags)
-{
-    SetListFromAny(interp, listPtr);
-    if ((idx >= 0 && idx >= listPtr->internalRep.listValue.len) ||
-        (idx < 0 && (-idx - 1) >= listPtr->internalRep.listValue.len)) {
-        if (flags & JIM_ERRMSG) {
-            Jim_SetResultString(interp, "list index out of range", -1);
-        }
-        return JIM_ERR;
-    }
-    if (idx < 0)
-        idx = listPtr->internalRep.listValue.len + idx;
-    Jim_DecrRefCount(interp, listPtr->internalRep.listValue.ele[idx]);
-    listPtr->internalRep.listValue.ele[idx] = newObjPtr;
-    Jim_IncrRefCount(newObjPtr);
-    return JIM_OK;
-}
-
-int Jim_ListSetIndex(Jim_Interp *interp, Jim_Obj *varNamePtr,
-    Jim_Obj *const *indexv, int indexc, Jim_Obj *newObjPtr)
-{
-    Jim_Obj *varObjPtr, *objPtr, *listObjPtr;
-    int shared, i, idx;
-
-    varObjPtr = objPtr = Jim_GetVariable(interp, varNamePtr, JIM_ERRMSG | JIM_UNSHARED);
-    if (objPtr == NULL)
-        return JIM_ERR;
-    if ((shared = Jim_IsShared(objPtr)))
-        varObjPtr = objPtr = Jim_DuplicateObj(interp, objPtr);
-    for (i = 0; i < indexc - 1; i++) {
-        listObjPtr = objPtr;
-        if (Jim_GetIndex(interp, indexv[i], &idx) != JIM_OK)
-            goto err;
-
-        objPtr = Jim_ListGetIndex(interp, listObjPtr, idx);
-        if (objPtr == NULL) {
-            Jim_SetResultFormatted(interp, "index \"%#s\" out of range", indexv[i]);
-            goto err;
-        }
-        if (Jim_IsShared(objPtr)) {
-            objPtr = Jim_DuplicateObj(interp, objPtr);
-            ListSetIndex(interp, listObjPtr, idx, objPtr, JIM_NONE);
-        }
-        Jim_InvalidateStringRep(listObjPtr);
-    }
-    if (Jim_GetIndex(interp, indexv[indexc - 1], &idx) != JIM_OK)
-        goto err;
-    if (ListSetIndex(interp, objPtr, idx, newObjPtr, JIM_ERRMSG) == JIM_ERR)
-        goto err;
-    Jim_InvalidateStringRep(objPtr);
-    Jim_InvalidateStringRep(varObjPtr);
-    if (Jim_SetVariable(interp, varNamePtr, varObjPtr) != JIM_OK)
-        goto err;
-    Jim_SetResult(interp, varObjPtr);
-    return JIM_OK;
-  err:
-    if (shared) {
-        Jim_FreeNewObj(interp, varObjPtr);
-    }
-    return JIM_ERR;
-}
-
-Jim_Obj *Jim_ListJoin(Jim_Interp *interp, Jim_Obj *listObjPtr, const char *joinStr, int joinStrLen)
-{
-    int i;
-    int listLen = Jim_ListLength(interp, listObjPtr);
-    Jim_Obj *resObjPtr = Jim_NewEmptyStringObj(interp);
-
-    for (i = 0; i < listLen; ) {
-        Jim_AppendObj(interp, resObjPtr, Jim_ListGetIndex(interp, listObjPtr, i));
-        if (++i != listLen) {
-            Jim_AppendString(interp, resObjPtr, joinStr, joinStrLen);
-        }
-    }
-    return resObjPtr;
-}
-
-Jim_Obj *Jim_ConcatObj(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
-{
-    int i;
-
-    for (i = 0; i < objc; i++) {
-        if (!Jim_IsList(objv[i]))
-            break;
-    }
-    if (i == objc) {
-        Jim_Obj *objPtr = Jim_NewListObj(interp, NULL, 0);
-
-        for (i = 0; i < objc; i++)
-            ListAppendList(objPtr, objv[i]);
-        return objPtr;
-    }
-    else {
-
-        int len = 0, objLen;
-        char *bytes, *p;
-
-
-        for (i = 0; i < objc; i++) {
-            len += Jim_Length(objv[i]);
-        }
-        if (objc)
-            len += objc - 1;
-
-        p = bytes = Jim_Alloc(len + 1);
-        for (i = 0; i < objc; i++) {
-            const char *s = Jim_GetString(objv[i], &objLen);
-
-
-            while (objLen && isspace(UCHAR(*s))) {
-                s++;
-                objLen--;
-                len--;
-            }
-
-            while (objLen && isspace(UCHAR(s[objLen - 1]))) {
-
-                if (objLen > 1 && s[objLen - 2] == '\\') {
-                    break;
-                }
-                objLen--;
-                len--;
-            }
-            memcpy(p, s, objLen);
-            p += objLen;
-            if (i + 1 != objc) {
-                if (objLen)
-                    *p++ = ' ';
-                else {
-                    len--;
-                }
-            }
-        }
-        *p = '\0';
-        return Jim_NewStringObjNoAlloc(interp, bytes, len);
-    }
-}
-
-Jim_Obj *Jim_ListRange(Jim_Interp *interp, Jim_Obj *listObjPtr, Jim_Obj *firstObjPtr,
-    Jim_Obj *lastObjPtr)
-{
-    int first, last;
-    int len, rangeLen;
-
-    if (Jim_GetIndex(interp, firstObjPtr, &first) != JIM_OK ||
-        Jim_GetIndex(interp, lastObjPtr, &last) != JIM_OK)
-        return NULL;
-    len = Jim_ListLength(interp, listObjPtr);
-    first = JimRelToAbsIndex(len, first);
-    last = JimRelToAbsIndex(len, last);
-    JimRelToAbsRange(len, &first, &last, &rangeLen);
-    if (first == 0 && last == len) {
-        return listObjPtr;
-    }
-    return Jim_NewListObj(interp, listObjPtr->internalRep.listValue.ele + first, rangeLen);
-}
-
-static void FreeDictInternalRep(Jim_Interp *interp, Jim_Obj *objPtr);
-static void DupDictInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
-static void UpdateStringOfDict(struct Jim_Obj *objPtr);
-static int SetDictFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
-
-
-static const Jim_ObjType dictObjType = {
-    "dict",
-    FreeDictInternalRep,
-    DupDictInternalRep,
-    UpdateStringOfDict,
-    JIM_TYPE_NONE,
-};
-
-static void JimFreeDict(Jim_Interp *interp, Jim_Dict *dict)
-{
-    int i;
-    for (i = 0; i < dict->len; i++) {
-        Jim_DecrRefCount(interp, dict->table[i]);
-    }
-    Jim_Free(dict->table);
-    Jim_Free(dict->ht);
-    Jim_Free(dict);
-}
-
-enum {
-    DICT_HASH_FIND = -1,
-    DICT_HASH_REMOVE = -2,
-    DICT_HASH_ADD = -3,
-};
-
-static int JimDictHashFind(Jim_Dict *dict, Jim_Obj *keyObjPtr, int op_tvoffset)
-{
-    unsigned h = (JimObjectHTHashFunction(keyObjPtr) + dict->uniq);
-    unsigned idx = h & dict->sizemask;
-    int tvoffset = 0;
-    unsigned peturb = h;
-    unsigned first_removed = ~0;
-
-    if (dict->len) {
-        while ((tvoffset = dict->ht[idx].offset)) {
-            if (tvoffset == -1) {
-                if (first_removed == ~0) {
-                    first_removed = idx;
-                }
-            }
-            else if (dict->ht[idx].hash == h) {
-                if (Jim_StringEqObj(keyObjPtr, dict->table[tvoffset - 1])) {
-                    break;
-                }
-            }
-
-            peturb >>= 5;
-            idx = (5 * idx + 1 + peturb) & dict->sizemask;
-        }
-    }
-
-    switch (op_tvoffset) {
-        case DICT_HASH_FIND:
-
-            break;
-        case DICT_HASH_REMOVE:
-            if (tvoffset) {
-
-                dict->ht[idx].offset = -1;
-                dict->dummy++;
-            }
-
-            break;
-        case DICT_HASH_ADD:
-            if (tvoffset == 0) {
-
-                if (first_removed != ~0) {
-                    idx = first_removed;
-                    dict->dummy--;
-                }
-                dict->ht[idx].offset = dict->len + 1;
-                dict->ht[idx].hash = h;
-            }
-
-            break;
-        default:
-            assert(tvoffset);
-
-            dict->ht[idx].offset = op_tvoffset;
-            break;
-    }
-
-    return tvoffset;
-}
-
-static void JimDictExpandHashTable(Jim_Dict *dict, unsigned int size)
-{
-    int i;
-    struct JimDictHashEntry *prevht = dict->ht;
-    int prevsize = dict->size;
-
-    dict->size = JimHashTableNextPower(size);
-    dict->sizemask = dict->size - 1;
-
-
-    dict->ht = Jim_Alloc(dict->size * sizeof(*dict->ht));
-    memset(dict->ht, 0, dict->size * sizeof(*dict->ht));
-
-
-    for (i = 0; i < prevsize; i++) {
-        if (prevht[i].offset > 0) {
-
-            unsigned h = prevht[i].hash;
-            unsigned idx = h & dict->sizemask;
-            unsigned peturb = h;
-
-            while (dict->ht[idx].offset) {
-                peturb >>= 5;
-                idx = (5 * idx + 1 + peturb) & dict->sizemask;
-            }
-            dict->ht[idx].offset = prevht[i].offset;
-            dict->ht[idx].hash = h;
-        }
-    }
-    Jim_Free(prevht);
-}
-
-static int JimDictAdd(Jim_Dict *dict, Jim_Obj *keyObjPtr)
-{
-    if (dict->size <= dict->len + dict->dummy) {
-        JimDictExpandHashTable(dict, dict->size ? dict->size * 2 : 8);
-    }
-    return JimDictHashFind(dict, keyObjPtr, DICT_HASH_ADD);
-}
-
-static Jim_Dict *JimDictNew(Jim_Interp *interp, int table_size, int ht_size)
-{
-    Jim_Dict *dict = Jim_Alloc(sizeof(*dict));
-    memset(dict, 0, sizeof(*dict));
-
-    if (ht_size) {
-        JimDictExpandHashTable(dict, ht_size);
-    }
-    if (table_size) {
-        dict->table = Jim_Alloc(table_size * sizeof(*dict->table));
-        dict->maxLen = table_size;
-    }
-#ifdef JIM_RANDOMISE_HASH
-    dict->uniq = (rand() ^ time(NULL) ^ clock());
-#endif
-    return dict;
-}
-
-static void FreeDictInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    JimFreeDict(interp, objPtr->internalRep.dictValue);
-}
-
-static void DupDictInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
-{
-    Jim_Dict *oldDict = srcPtr->internalRep.dictValue;
-    int i;
-
-
-    Jim_Dict *newDict = JimDictNew(interp, oldDict->maxLen, oldDict->size);
-
-
-    for (i = 0; i < oldDict->len; i++) {
-        newDict->table[i] = oldDict->table[i];
-        Jim_IncrRefCount(newDict->table[i]);
-    }
-    newDict->len = oldDict->len;
-
-
-    newDict->uniq = oldDict->uniq;
-
-
-    memcpy(newDict->ht, oldDict->ht, sizeof(*oldDict->ht) * oldDict->size);
-
-    dupPtr->internalRep.dictValue = newDict;
-    dupPtr->typePtr = &dictObjType;
-}
-
-static void UpdateStringOfDict(struct Jim_Obj *objPtr)
-{
-    JimMakeListStringRep(objPtr, objPtr->internalRep.dictValue->table, objPtr->internalRep.dictValue->len);
-}
-
-static int SetDictFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
-{
-    int listlen;
-
-    if (objPtr->typePtr == &dictObjType) {
-        return JIM_OK;
-    }
-
-    if (Jim_IsList(objPtr) && Jim_IsShared(objPtr)) {
-        Jim_String(objPtr);
-    }
-
-    listlen = Jim_ListLength(interp, objPtr);
-    if (listlen % 2) {
-        Jim_SetResultString(interp, "missing value to go with key", -1);
-        return JIM_ERR;
-    }
-    else {
-
-        Jim_Dict *dict = JimDictNew(interp, 0, listlen);
-        int i;
-
-
-        dict->table = objPtr->internalRep.listValue.ele;
-        dict->maxLen = objPtr->internalRep.listValue.maxLen;
-
-
-        for (i = 0; i < listlen; i += 2) {
-            int tvoffset = JimDictAdd(dict, dict->table[i]);
-            if (tvoffset) {
-
-
-                Jim_DecrRefCount(interp, dict->table[tvoffset]);
-
-                dict->table[tvoffset] = dict->table[i + 1];
-
-                Jim_DecrRefCount(interp, dict->table[i]);
-            }
-            else {
-                if (dict->len != i) {
-                    dict->table[dict->len++] = dict->table[i];
-                    dict->table[dict->len++] = dict->table[i + 1];
-                }
-                else {
-                    dict->len += 2;
-                }
-            }
-        }
-
-        objPtr->typePtr = &dictObjType;
-        objPtr->internalRep.dictValue = dict;
-
-        return JIM_OK;
-    }
-}
-
-
-
-static int DictAddElement(Jim_Interp *interp, Jim_Obj *objPtr,
-    Jim_Obj *keyObjPtr, Jim_Obj *valueObjPtr)
-{
-    Jim_Dict *dict = objPtr->internalRep.dictValue;
-    if (valueObjPtr == NULL) {
-
-        int tvoffset = JimDictHashFind(dict, keyObjPtr, DICT_HASH_REMOVE);
-        if (tvoffset) {
-
-            Jim_DecrRefCount(interp, dict->table[tvoffset - 1]);
-            Jim_DecrRefCount(interp, dict->table[tvoffset]);
-            dict->len -= 2;
-            if (tvoffset != dict->len + 1) {
-
-                dict->table[tvoffset - 1] = dict->table[dict->len];
-                dict->table[tvoffset] = dict->table[dict->len + 1];
-
-
-                JimDictHashFind(dict, dict->table[tvoffset - 1], tvoffset);
-            }
-            return JIM_OK;
-        }
-        return JIM_ERR;
-    }
-    else {
-
-        int tvoffset = JimDictAdd(dict, keyObjPtr);
-        if (tvoffset) {
-
-            Jim_IncrRefCount(valueObjPtr);
-            Jim_DecrRefCount(interp, dict->table[tvoffset]);
-            dict->table[tvoffset] = valueObjPtr;
-        }
-        else {
-            if (dict->maxLen == dict->len) {
-
-                if (dict->maxLen < 4) {
-                    dict->maxLen = 4;
-                }
-                else {
-                    dict->maxLen *= 2;
-                }
-                dict->table = Jim_Realloc(dict->table, dict->maxLen * sizeof(*dict->table));
-            }
-            Jim_IncrRefCount(keyObjPtr);
-            Jim_IncrRefCount(valueObjPtr);
-
-            dict->table[dict->len++] = keyObjPtr;
-            dict->table[dict->len++] = valueObjPtr;
-
-        }
-        return JIM_OK;
-    }
-}
-
-int Jim_DictAddElement(Jim_Interp *interp, Jim_Obj *objPtr,
-    Jim_Obj *keyObjPtr, Jim_Obj *valueObjPtr)
-{
-    JimPanic((Jim_IsShared(objPtr), "Jim_DictAddElement called with shared object"));
-    if (SetDictFromAny(interp, objPtr) != JIM_OK) {
-        return JIM_ERR;
-    }
-    Jim_InvalidateStringRep(objPtr);
-    return DictAddElement(interp, objPtr, keyObjPtr, valueObjPtr);
-}
-
-Jim_Obj *Jim_NewDictObj(Jim_Interp *interp, Jim_Obj *const *elements, int len)
-{
-    Jim_Obj *objPtr;
-    int i;
-
-    JimPanic((len % 2, "Jim_NewDictObj() 'len' argument must be even"));
-
-    objPtr = Jim_NewObj(interp);
-    objPtr->typePtr = &dictObjType;
-    objPtr->bytes = NULL;
-
-    objPtr->internalRep.dictValue = JimDictNew(interp, len, len);
-    for (i = 0; i < len; i += 2)
-        DictAddElement(interp, objPtr, elements[i], elements[i + 1]);
-    return objPtr;
-}
-
-int Jim_DictKey(Jim_Interp *interp, Jim_Obj *dictPtr, Jim_Obj *keyPtr,
-    Jim_Obj **objPtrPtr, int flags)
-{
-    int tvoffset;
-    Jim_Dict *dict;
-
-    if (SetDictFromAny(interp, dictPtr) != JIM_OK) {
-        return -1;
-    }
-    dict = dictPtr->internalRep.dictValue;
-    tvoffset = JimDictHashFind(dict, keyPtr, DICT_HASH_FIND);
-    if (tvoffset == 0) {
-        if (flags & JIM_ERRMSG) {
-            Jim_SetResultFormatted(interp, "key \"%#s\" not known in dictionary", keyPtr);
-        }
-        return JIM_ERR;
-    }
-    *objPtrPtr = dict->table[tvoffset];
-    return JIM_OK;
-}
-
-Jim_Obj **Jim_DictPairs(Jim_Interp *interp, Jim_Obj *dictPtr, int *len)
-{
-
-    if (Jim_IsList(dictPtr)) {
-        Jim_Obj **table;
-        JimListGetElements(interp, dictPtr, len, &table);
-        if (*len % 2 == 0) {
-            return table;
-        }
-
-    }
-    if (SetDictFromAny(interp, dictPtr) != JIM_OK) {
-
-        *len = 1;
-        return NULL;
-    }
-    *len = dictPtr->internalRep.dictValue->len;
-    return dictPtr->internalRep.dictValue->table;
-}
-
-
-int Jim_DictKeysVector(Jim_Interp *interp, Jim_Obj *dictPtr,
-    Jim_Obj *const *keyv, int keyc, Jim_Obj **objPtrPtr, int flags)
-{
-    int i;
-
-    if (keyc == 0) {
-        *objPtrPtr = dictPtr;
-        return JIM_OK;
-    }
-
-    for (i = 0; i < keyc; i++) {
-        Jim_Obj *objPtr;
-
-        int rc = Jim_DictKey(interp, dictPtr, keyv[i], &objPtr, flags);
-        if (rc != JIM_OK) {
-            return rc;
-        }
-        dictPtr = objPtr;
-    }
-    *objPtrPtr = dictPtr;
-    return JIM_OK;
-}
-
-int Jim_SetDictKeysVector(Jim_Interp *interp, Jim_Obj *varNamePtr,
-    Jim_Obj *const *keyv, int keyc, Jim_Obj *newObjPtr, int flags)
-{
-    Jim_Obj *varObjPtr, *objPtr, *dictObjPtr;
-    int shared, i;
-
-    varObjPtr = objPtr = Jim_GetVariable(interp, varNamePtr, flags);
-    if (objPtr == NULL) {
-        if (newObjPtr == NULL && (flags & JIM_MUSTEXIST)) {
-
-            return JIM_ERR;
-        }
-        varObjPtr = objPtr = Jim_NewDictObj(interp, NULL, 0);
-        if (Jim_SetVariable(interp, varNamePtr, objPtr) != JIM_OK) {
-            Jim_FreeNewObj(interp, varObjPtr);
-            return JIM_ERR;
-        }
-    }
-    if ((shared = Jim_IsShared(objPtr)))
-        varObjPtr = objPtr = Jim_DuplicateObj(interp, objPtr);
-    for (i = 0; i < keyc; i++) {
-        dictObjPtr = objPtr;
-
-
-        if (SetDictFromAny(interp, dictObjPtr) != JIM_OK) {
-            goto err;
-        }
-
-        if (i == keyc - 1) {
-
-            if (Jim_DictAddElement(interp, objPtr, keyv[keyc - 1], newObjPtr) != JIM_OK) {
-                if (newObjPtr || (flags & JIM_MUSTEXIST)) {
-                    goto err;
-                }
-            }
-            break;
-        }
-
-
-        Jim_InvalidateStringRep(dictObjPtr);
-        if (Jim_DictKey(interp, dictObjPtr, keyv[i], &objPtr,
-                newObjPtr ? JIM_NONE : JIM_ERRMSG) == JIM_OK) {
-            if (Jim_IsShared(objPtr)) {
-                objPtr = Jim_DuplicateObj(interp, objPtr);
-                DictAddElement(interp, dictObjPtr, keyv[i], objPtr);
-            }
-        }
-        else {
-            if (newObjPtr == NULL) {
-                goto err;
-            }
-            objPtr = Jim_NewDictObj(interp, NULL, 0);
-            DictAddElement(interp, dictObjPtr, keyv[i], objPtr);
-        }
-    }
-
-    Jim_InvalidateStringRep(objPtr);
-    Jim_InvalidateStringRep(varObjPtr);
-    if (Jim_SetVariable(interp, varNamePtr, varObjPtr) != JIM_OK) {
-        goto err;
-    }
-
-    if (!(flags & JIM_NORESULT)) {
-        Jim_SetResult(interp, varObjPtr);
-    }
-    return JIM_OK;
-  err:
-    if (shared) {
-        Jim_FreeNewObj(interp, varObjPtr);
-    }
-    return JIM_ERR;
-}
-
-static void UpdateStringOfIndex(struct Jim_Obj *objPtr);
-static int SetIndexFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
-
-static const Jim_ObjType indexObjType = {
-    "index",
-    NULL,
-    NULL,
-    UpdateStringOfIndex,
-    JIM_TYPE_NONE,
-};
-
-static void UpdateStringOfIndex(struct Jim_Obj *objPtr)
-{
-    if (objPtr->internalRep.intValue == -1) {
-        JimSetStringBytes(objPtr, "end");
-    }
-    else {
-        char buf[JIM_INTEGER_SPACE + 1];
-        if (objPtr->internalRep.intValue >= 0 || objPtr->internalRep.intValue == -INT_MAX) {
-            sprintf(buf, "%d", objPtr->internalRep.intValue);
-        }
-        else {
-
-            sprintf(buf, "end%d", objPtr->internalRep.intValue + 1);
-        }
-        JimSetStringBytes(objPtr, buf);
-    }
-}
-
-static int SetIndexFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    jim_wide idx;
-    int end = 0;
-    const char *str;
-    Jim_Obj *exprObj = objPtr;
-
-    JimPanic((objPtr->refCount == 0, "SetIndexFromAny() called with zero refcount object"));
-
-
-    str = Jim_String(objPtr);
-
-
-    if (strncmp(str, "end", 3) == 0) {
-        end = 1;
-        str += 3;
-        idx = 0;
-        switch (*str) {
-            case '\0':
-                exprObj = NULL;
-                break;
-
-            case '-':
-            case '+':
-                exprObj = Jim_NewStringObj(interp, str, -1);
-                break;
-
-            default:
-                goto badindex;
-        }
-    }
-    if (exprObj) {
-        int ret;
-        Jim_IncrRefCount(exprObj);
-        ret = Jim_GetWideExpr(interp, exprObj, &idx);
-        Jim_DecrRefCount(interp, exprObj);
-        if (ret != JIM_OK) {
-            goto badindex;
-        }
-    }
-
-    if (end) {
-        if (idx > 0) {
-            idx = INT_MAX;
-        }
-        else {
-
-            idx--;
-        }
-    }
-    else if (idx < 0) {
-        idx = -INT_MAX;
-    }
-
-
-    Jim_FreeIntRep(interp, objPtr);
-    objPtr->typePtr = &indexObjType;
-    objPtr->internalRep.intValue = idx;
-    return JIM_OK;
-
-  badindex:
-    Jim_SetResultFormatted(interp,
-        "bad index \"%#s\": must be intexpr or end?[+-]intexpr?", objPtr);
-    return JIM_ERR;
-}
-
-int Jim_GetIndex(Jim_Interp *interp, Jim_Obj *objPtr, int *indexPtr)
-{
-
-    if (objPtr->typePtr == &intObjType) {
-        jim_wide val = JimWideValue(objPtr);
-
-        if (val < 0)
-            *indexPtr = -INT_MAX;
-        else if (val > INT_MAX)
-            *indexPtr = INT_MAX;
-        else
-            *indexPtr = (int)val;
-        return JIM_OK;
-    }
-    if (objPtr->typePtr != &indexObjType && SetIndexFromAny(interp, objPtr) == JIM_ERR)
-        return JIM_ERR;
-    *indexPtr = objPtr->internalRep.intValue;
-    return JIM_OK;
-}
-
-
-
-static const char * const jimReturnCodes[] = {
-    "ok",
-    "error",
-    "return",
-    "break",
-    "continue",
-    "signal",
-    "exit",
-    "eval",
-    NULL
-};
-
-#define jimReturnCodesSize (sizeof(jimReturnCodes)/sizeof(*jimReturnCodes) - 1)
-
-static const Jim_ObjType returnCodeObjType = {
-    "return-code",
-    NULL,
-    NULL,
-    NULL,
-    JIM_TYPE_NONE,
-};
-
-const char *Jim_ReturnCode(int code)
-{
-    if (code < 0 || code >= (int)jimReturnCodesSize) {
-        return "?";
-    }
-    else {
-        return jimReturnCodes[code];
-    }
-}
-
-static int SetReturnCodeFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    int returnCode;
-    jim_wide wideValue;
-
-
-    if (JimGetWideNoErr(interp, objPtr, &wideValue) != JIM_ERR)
-        returnCode = (int)wideValue;
-    else if (Jim_GetEnum(interp, objPtr, jimReturnCodes, &returnCode, NULL, JIM_NONE) != JIM_OK) {
-        Jim_SetResultFormatted(interp, "expected return code but got \"%#s\"", objPtr);
-        return JIM_ERR;
-    }
-
-    Jim_FreeIntRep(interp, objPtr);
-    objPtr->typePtr = &returnCodeObjType;
-    objPtr->internalRep.intValue = returnCode;
-    return JIM_OK;
-}
-
-int Jim_GetReturnCode(Jim_Interp *interp, Jim_Obj *objPtr, int *intPtr)
-{
-    if (objPtr->typePtr != &returnCodeObjType && SetReturnCodeFromAny(interp, objPtr) == JIM_ERR)
-        return JIM_ERR;
-    *intPtr = objPtr->internalRep.intValue;
-    return JIM_OK;
-}
-
-static int JimParseExprOperator(struct JimParserCtx *pc);
-static int JimParseExprNumber(struct JimParserCtx *pc);
-static int JimParseExprIrrational(struct JimParserCtx *pc);
-static int JimParseExprBoolean(struct JimParserCtx *pc);
-
-
-enum
-{
-
-
-
-    JIM_EXPROP_MUL = JIM_TT_EXPR_OP,
-    JIM_EXPROP_DIV,
-    JIM_EXPROP_MOD,
-    JIM_EXPROP_SUB,
-    JIM_EXPROP_ADD,
-    JIM_EXPROP_LSHIFT,
-    JIM_EXPROP_RSHIFT,
-    JIM_EXPROP_ROTL,
-    JIM_EXPROP_ROTR,
-    JIM_EXPROP_LT,
-    JIM_EXPROP_GT,
-    JIM_EXPROP_LTE,
-    JIM_EXPROP_GTE,
-    JIM_EXPROP_NUMEQ,
-    JIM_EXPROP_NUMNE,
-    JIM_EXPROP_BITAND,
-    JIM_EXPROP_BITXOR,
-    JIM_EXPROP_BITOR,
-    JIM_EXPROP_LOGICAND,
-    JIM_EXPROP_LOGICOR,
-    JIM_EXPROP_TERNARY,
-    JIM_EXPROP_COLON,
-    JIM_EXPROP_POW,
-
-
-    JIM_EXPROP_STREQ,
-    JIM_EXPROP_STRNE,
-    JIM_EXPROP_STRIN,
-    JIM_EXPROP_STRNI,
-    JIM_EXPROP_STRLT,
-    JIM_EXPROP_STRGT,
-    JIM_EXPROP_STRLE,
-    JIM_EXPROP_STRGE,
-
-
-    JIM_EXPROP_NOT,
-    JIM_EXPROP_BITNOT,
-    JIM_EXPROP_UNARYMINUS,
-    JIM_EXPROP_UNARYPLUS,
-
-
-    JIM_EXPROP_FUNC_INT,
-    JIM_EXPROP_FUNC_WIDE,
-    JIM_EXPROP_FUNC_ABS,
-    JIM_EXPROP_FUNC_DOUBLE,
-    JIM_EXPROP_FUNC_ROUND,
-    JIM_EXPROP_FUNC_RAND,
-    JIM_EXPROP_FUNC_SRAND,
-
-
-    JIM_EXPROP_FUNC_SIN,
-    JIM_EXPROP_FUNC_COS,
-    JIM_EXPROP_FUNC_TAN,
-    JIM_EXPROP_FUNC_ASIN,
-    JIM_EXPROP_FUNC_ACOS,
-    JIM_EXPROP_FUNC_ATAN,
-    JIM_EXPROP_FUNC_ATAN2,
-    JIM_EXPROP_FUNC_SINH,
-    JIM_EXPROP_FUNC_COSH,
-    JIM_EXPROP_FUNC_TANH,
-    JIM_EXPROP_FUNC_CEIL,
-    JIM_EXPROP_FUNC_FLOOR,
-    JIM_EXPROP_FUNC_EXP,
-    JIM_EXPROP_FUNC_LOG,
-    JIM_EXPROP_FUNC_LOG10,
-    JIM_EXPROP_FUNC_SQRT,
-    JIM_EXPROP_FUNC_POW,
-    JIM_EXPROP_FUNC_HYPOT,
-    JIM_EXPROP_FUNC_FMOD,
-};
-
-struct JimExprNode {
-    int type;
-    struct Jim_Obj *objPtr;
-
-    struct JimExprNode *left;
-    struct JimExprNode *right;
-    struct JimExprNode *ternary;
-};
-
-
-typedef struct Jim_ExprOperator
-{
-    const char *name;
-    int (*funcop) (Jim_Interp *interp, struct JimExprNode *opnode);
-    unsigned char precedence;
-    unsigned char arity;
-    unsigned char attr;
-    unsigned char namelen;
-} Jim_ExprOperator;
-
-static int JimExprGetTerm(Jim_Interp *interp, struct JimExprNode *node, Jim_Obj **objPtrPtr);
-static int JimExprGetTermBoolean(Jim_Interp *interp, struct JimExprNode *node);
-static int JimExprEvalTermNode(Jim_Interp *interp, struct JimExprNode *node);
-
-static int JimExprOpNumUnary(Jim_Interp *interp, struct JimExprNode *node)
-{
-    int intresult = 1;
-    int rc, bA = 0;
-    double dA, dC = 0;
-    jim_wide wA, wC = 0;
-    Jim_Obj *A;
-
-    if ((rc = JimExprGetTerm(interp, node->left, &A)) != JIM_OK) {
-        return rc;
-    }
-
-    if ((A->typePtr != &doubleObjType || A->bytes) && JimGetWideNoErr(interp, A, &wA) == JIM_OK) {
-        switch (node->type) {
-            case JIM_EXPROP_FUNC_INT:
-            case JIM_EXPROP_FUNC_WIDE:
-            case JIM_EXPROP_FUNC_ROUND:
-            case JIM_EXPROP_UNARYPLUS:
-                wC = wA;
-                break;
-            case JIM_EXPROP_FUNC_DOUBLE:
-                dC = wA;
-                intresult = 0;
-                break;
-            case JIM_EXPROP_FUNC_ABS:
-                wC = wA >= 0 ? wA : -wA;
-                break;
-            case JIM_EXPROP_UNARYMINUS:
-                wC = -wA;
-                break;
-            case JIM_EXPROP_NOT:
-                wC = !wA;
-                break;
-            default:
-                abort();
-        }
-    }
-    else if ((rc = Jim_GetDouble(interp, A, &dA)) == JIM_OK) {
-        switch (node->type) {
-            case JIM_EXPROP_FUNC_INT:
-            case JIM_EXPROP_FUNC_WIDE:
-                wC = dA;
-                break;
-            case JIM_EXPROP_FUNC_ROUND:
-                wC = dA < 0 ? (dA - 0.5) : (dA + 0.5);
-                break;
-            case JIM_EXPROP_FUNC_DOUBLE:
-            case JIM_EXPROP_UNARYPLUS:
-                dC = dA;
-                intresult = 0;
-                break;
-            case JIM_EXPROP_FUNC_ABS:
-#ifdef JIM_MATH_FUNCTIONS
-                dC = fabs(dA);
-#else
-                dC = dA >= 0 ? dA : -dA;
-#endif
-                intresult = 0;
-                break;
-            case JIM_EXPROP_UNARYMINUS:
-                dC = -dA;
-                intresult = 0;
-                break;
-            case JIM_EXPROP_NOT:
-                wC = !dA;
-                break;
-            default:
-                abort();
-        }
-    }
-    else if ((rc = Jim_GetBoolean(interp, A, &bA)) == JIM_OK) {
-        switch (node->type) {
-            case JIM_EXPROP_NOT:
-                wC = !bA;
-                break;
-            default:
-                abort();
-        }
-    }
-
-    if (rc == JIM_OK) {
-        if (intresult) {
-            Jim_SetResultInt(interp, wC);
-        }
-        else {
-            Jim_SetResult(interp, Jim_NewDoubleObj(interp, dC));
-        }
-    }
-
-    Jim_DecrRefCount(interp, A);
-
-    return rc;
-}
-
-static double JimRandDouble(Jim_Interp *interp)
-{
-    unsigned long x;
-    JimRandomBytes(interp, &x, sizeof(x));
-
-    return (double)x / (double)~0UL;
-}
-
-static int JimExprOpIntUnary(Jim_Interp *interp, struct JimExprNode *node)
-{
-    jim_wide wA;
-    Jim_Obj *A;
-    int rc;
-
-    if ((rc = JimExprGetTerm(interp, node->left, &A)) != JIM_OK) {
-        return rc;
-    }
-
-    rc = Jim_GetWide(interp, A, &wA);
-    if (rc == JIM_OK) {
-        switch (node->type) {
-            case JIM_EXPROP_BITNOT:
-                Jim_SetResultInt(interp, ~wA);
-                break;
-            case JIM_EXPROP_FUNC_SRAND:
-                JimPrngSeed(interp, (unsigned char *)&wA, sizeof(wA));
-                Jim_SetResult(interp, Jim_NewDoubleObj(interp, JimRandDouble(interp)));
-                break;
-            default:
-                abort();
-        }
-    }
-
-    Jim_DecrRefCount(interp, A);
-
-    return rc;
-}
-
-static int JimExprOpNone(Jim_Interp *interp, struct JimExprNode *node)
-{
-    JimPanic((node->type != JIM_EXPROP_FUNC_RAND, "JimExprOpNone only support rand()"));
-
-    Jim_SetResult(interp, Jim_NewDoubleObj(interp, JimRandDouble(interp)));
-
-    return JIM_OK;
-}
-
-#ifdef JIM_MATH_FUNCTIONS
-static int JimExprOpDoubleUnary(Jim_Interp *interp, struct JimExprNode *node)
-{
-    int rc;
-    double dA, dC;
-    Jim_Obj *A;
-
-    if ((rc = JimExprGetTerm(interp, node->left, &A)) != JIM_OK) {
-        return rc;
-    }
-
-    rc = Jim_GetDouble(interp, A, &dA);
-    if (rc == JIM_OK) {
-        switch (node->type) {
-            case JIM_EXPROP_FUNC_SIN:
-                dC = sin(dA);
-                break;
-            case JIM_EXPROP_FUNC_COS:
-                dC = cos(dA);
-                break;
-            case JIM_EXPROP_FUNC_TAN:
-                dC = tan(dA);
-                break;
-            case JIM_EXPROP_FUNC_ASIN:
-                dC = asin(dA);
-                break;
-            case JIM_EXPROP_FUNC_ACOS:
-                dC = acos(dA);
-                break;
-            case JIM_EXPROP_FUNC_ATAN:
-                dC = atan(dA);
-                break;
-            case JIM_EXPROP_FUNC_SINH:
-                dC = sinh(dA);
-                break;
-            case JIM_EXPROP_FUNC_COSH:
-                dC = cosh(dA);
-                break;
-            case JIM_EXPROP_FUNC_TANH:
-                dC = tanh(dA);
-                break;
-            case JIM_EXPROP_FUNC_CEIL:
-                dC = ceil(dA);
-                break;
-            case JIM_EXPROP_FUNC_FLOOR:
-                dC = floor(dA);
-                break;
-            case JIM_EXPROP_FUNC_EXP:
-                dC = exp(dA);
-                break;
-            case JIM_EXPROP_FUNC_LOG:
-                dC = log(dA);
-                break;
-            case JIM_EXPROP_FUNC_LOG10:
-                dC = log10(dA);
-                break;
-            case JIM_EXPROP_FUNC_SQRT:
-                dC = sqrt(dA);
-                break;
-            default:
-                abort();
-        }
-        Jim_SetResult(interp, Jim_NewDoubleObj(interp, dC));
-    }
-
-    Jim_DecrRefCount(interp, A);
-
-    return rc;
-}
-#endif
-
-
-static int JimExprOpIntBin(Jim_Interp *interp, struct JimExprNode *node)
-{
-    jim_wide wA, wB;
-    int rc;
-    Jim_Obj *A, *B;
-
-    if ((rc = JimExprGetTerm(interp, node->left, &A)) != JIM_OK) {
-        return rc;
-    }
-    if ((rc = JimExprGetTerm(interp, node->right, &B)) != JIM_OK) {
-        Jim_DecrRefCount(interp, A);
-        return rc;
-    }
-
-    rc = JIM_ERR;
-
-    if (Jim_GetWide(interp, A, &wA) == JIM_OK && Jim_GetWide(interp, B, &wB) == JIM_OK) {
-        jim_wide wC;
-
-        rc = JIM_OK;
-
-        switch (node->type) {
-            case JIM_EXPROP_LSHIFT:
-                wC = wA << wB;
-                break;
-            case JIM_EXPROP_RSHIFT:
-                wC = wA >> wB;
-                break;
-            case JIM_EXPROP_BITAND:
-                wC = wA & wB;
-                break;
-            case JIM_EXPROP_BITXOR:
-                wC = wA ^ wB;
-                break;
-            case JIM_EXPROP_BITOR:
-                wC = wA | wB;
-                break;
-            case JIM_EXPROP_MOD:
-                if (wB == 0) {
-                    wC = 0;
-                    Jim_SetResultString(interp, "Division by zero", -1);
-                    rc = JIM_ERR;
-                }
-                else {
-                    int negative = 0;
-
-                    if (wB < 0) {
-                        wB = -wB;
-                        wA = -wA;
-                        negative = 1;
-                    }
-                    wC = wA % wB;
-                    if (wC < 0) {
-                        wC += wB;
-                    }
-                    if (negative) {
-                        wC = -wC;
-                    }
-                }
-                break;
-            case JIM_EXPROP_ROTL:
-            case JIM_EXPROP_ROTR:{
-
-                    unsigned long uA = (unsigned long)wA;
-                    unsigned long uB = (unsigned long)wB;
-                    const unsigned int S = sizeof(unsigned long) * 8;
-
-
-                    uB %= S;
-
-                    if (node->type == JIM_EXPROP_ROTR) {
-                        uB = S - uB;
-                    }
-                    wC = (unsigned long)(uA << uB) | (uA >> (S - uB));
-                    break;
-                }
-            default:
-                abort();
-        }
-        Jim_SetResultInt(interp, wC);
-    }
-
-    Jim_DecrRefCount(interp, A);
-    Jim_DecrRefCount(interp, B);
-
-    return rc;
-}
-
-
-
-static int JimExprOpBin(Jim_Interp *interp, struct JimExprNode *node)
-{
-    int rc = JIM_OK;
-    double dA, dB, dC = 0;
-    jim_wide wA, wB, wC = 0;
-    Jim_Obj *A, *B;
-
-    if ((rc = JimExprGetTerm(interp, node->left, &A)) != JIM_OK) {
-        return rc;
-    }
-    if ((rc = JimExprGetTerm(interp, node->right, &B)) != JIM_OK) {
-        Jim_DecrRefCount(interp, A);
-        return rc;
-    }
-
-    if ((A->typePtr != &doubleObjType || A->bytes) &&
-        (B->typePtr != &doubleObjType || B->bytes) &&
-        JimGetWideNoErr(interp, A, &wA) == JIM_OK && JimGetWideNoErr(interp, B, &wB) == JIM_OK) {
-
-
-
-        switch (node->type) {
-            case JIM_EXPROP_POW:
-            case JIM_EXPROP_FUNC_POW:
-                if (wA == 0 && wB < 0) {
-                    Jim_SetResultString(interp, "exponentiation of zero by negative power", -1);
-                    rc = JIM_ERR;
-                    goto done;
-                }
-                wC = JimPowWide(wA, wB);
-                goto intresult;
-            case JIM_EXPROP_ADD:
-                wC = wA + wB;
-                goto intresult;
-            case JIM_EXPROP_SUB:
-                wC = wA - wB;
-                goto intresult;
-            case JIM_EXPROP_MUL:
-                wC = wA * wB;
-                goto intresult;
-            case JIM_EXPROP_DIV:
-                if (wB == 0) {
-                    Jim_SetResultString(interp, "Division by zero", -1);
-                    rc = JIM_ERR;
-                    goto done;
-                }
-                else {
-                    if (wB < 0) {
-                        wB = -wB;
-                        wA = -wA;
-                    }
-                    wC = wA / wB;
-                    if (wA % wB < 0) {
-                        wC--;
-                    }
-                    goto intresult;
-                }
-            case JIM_EXPROP_LT:
-                wC = wA < wB;
-                goto intresult;
-            case JIM_EXPROP_GT:
-                wC = wA > wB;
-                goto intresult;
-            case JIM_EXPROP_LTE:
-                wC = wA <= wB;
-                goto intresult;
-            case JIM_EXPROP_GTE:
-                wC = wA >= wB;
-                goto intresult;
-            case JIM_EXPROP_NUMEQ:
-                wC = wA == wB;
-                goto intresult;
-            case JIM_EXPROP_NUMNE:
-                wC = wA != wB;
-                goto intresult;
-        }
-    }
-    if (Jim_GetDouble(interp, A, &dA) == JIM_OK && Jim_GetDouble(interp, B, &dB) == JIM_OK) {
-        switch (node->type) {
-#ifndef JIM_MATH_FUNCTIONS
-            case JIM_EXPROP_POW:
-            case JIM_EXPROP_FUNC_POW:
-            case JIM_EXPROP_FUNC_ATAN2:
-            case JIM_EXPROP_FUNC_HYPOT:
-            case JIM_EXPROP_FUNC_FMOD:
-                Jim_SetResultString(interp, "unsupported", -1);
-                rc = JIM_ERR;
-                goto done;
-#else
-            case JIM_EXPROP_POW:
-            case JIM_EXPROP_FUNC_POW:
-                dC = pow(dA, dB);
-                goto doubleresult;
-            case JIM_EXPROP_FUNC_ATAN2:
-                dC = atan2(dA, dB);
-                goto doubleresult;
-            case JIM_EXPROP_FUNC_HYPOT:
-                dC = hypot(dA, dB);
-                goto doubleresult;
-            case JIM_EXPROP_FUNC_FMOD:
-                dC = fmod(dA, dB);
-                goto doubleresult;
-#endif
-            case JIM_EXPROP_ADD:
-                dC = dA + dB;
-                goto doubleresult;
-            case JIM_EXPROP_SUB:
-                dC = dA - dB;
-                goto doubleresult;
-            case JIM_EXPROP_MUL:
-                dC = dA * dB;
-                goto doubleresult;
-            case JIM_EXPROP_DIV:
-                if (dB == 0) {
-#ifdef INFINITY
-                    dC = dA < 0 ? -INFINITY : INFINITY;
-#else
-                    dC = (dA < 0 ? -1.0 : 1.0) * strtod("Inf", NULL);
-#endif
-                }
-                else {
-                    dC = dA / dB;
-                }
-                goto doubleresult;
-            case JIM_EXPROP_LT:
-                wC = dA < dB;
-                goto intresult;
-            case JIM_EXPROP_GT:
-                wC = dA > dB;
-                goto intresult;
-            case JIM_EXPROP_LTE:
-                wC = dA <= dB;
-                goto intresult;
-            case JIM_EXPROP_GTE:
-                wC = dA >= dB;
-                goto intresult;
-            case JIM_EXPROP_NUMEQ:
-                wC = dA == dB;
-                goto intresult;
-            case JIM_EXPROP_NUMNE:
-                wC = dA != dB;
-                goto intresult;
-        }
-    }
-    else {
-
-
-
-        int i = Jim_StringCompareObj(interp, A, B, 0);
-
-        switch (node->type) {
-            case JIM_EXPROP_LT:
-                wC = i < 0;
-                goto intresult;
-            case JIM_EXPROP_GT:
-                wC = i > 0;
-                goto intresult;
-            case JIM_EXPROP_LTE:
-                wC = i <= 0;
-                goto intresult;
-            case JIM_EXPROP_GTE:
-                wC = i >= 0;
-                goto intresult;
-            case JIM_EXPROP_NUMEQ:
-                wC = i == 0;
-                goto intresult;
-            case JIM_EXPROP_NUMNE:
-                wC = i != 0;
-                goto intresult;
-        }
-    }
-
-    rc = JIM_ERR;
-done:
-    Jim_DecrRefCount(interp, A);
-    Jim_DecrRefCount(interp, B);
-    return rc;
-intresult:
-    Jim_SetResultInt(interp, wC);
-    goto done;
-doubleresult:
-    Jim_SetResult(interp, Jim_NewDoubleObj(interp, dC));
-    goto done;
-}
-
-static int JimSearchList(Jim_Interp *interp, Jim_Obj *listObjPtr, Jim_Obj *valObj)
-{
-    int listlen;
-    int i;
-
-    listlen = Jim_ListLength(interp, listObjPtr);
-    for (i = 0; i < listlen; i++) {
-        if (Jim_StringEqObj(Jim_ListGetIndex(interp, listObjPtr, i), valObj)) {
-            return 1;
-        }
-    }
-    return 0;
-}
-
-
-
-static int JimExprOpStrBin(Jim_Interp *interp, struct JimExprNode *node)
-{
-    Jim_Obj *A, *B;
-    jim_wide wC;
-    int comp, rc;
-
-    if ((rc = JimExprGetTerm(interp, node->left, &A)) != JIM_OK) {
-        return rc;
-    }
-    if ((rc = JimExprGetTerm(interp, node->right, &B)) != JIM_OK) {
-        Jim_DecrRefCount(interp, A);
-        return rc;
-    }
-
-    switch (node->type) {
-        case JIM_EXPROP_STREQ:
-        case JIM_EXPROP_STRNE:
-            wC = Jim_StringEqObj(A, B);
-            if (node->type == JIM_EXPROP_STRNE) {
-                wC = !wC;
-            }
-            break;
-        case JIM_EXPROP_STRLT:
-        case JIM_EXPROP_STRGT:
-        case JIM_EXPROP_STRLE:
-        case JIM_EXPROP_STRGE:
-            comp = Jim_StringCompareObj(interp, A, B, 0);
-            if (node->type == JIM_EXPROP_STRLT) {
-                wC = comp == -1;
-            } else if (node->type == JIM_EXPROP_STRGT) {
-                wC = comp == 1;
-            } else if (node->type == JIM_EXPROP_STRLE) {
-                wC = comp == -1 || comp == 0;
-            } else {
-                wC = comp == 0 || comp == 1;
-            }
-            break;
-        case JIM_EXPROP_STRIN:
-            wC = JimSearchList(interp, B, A);
-            break;
-        case JIM_EXPROP_STRNI:
-            wC = !JimSearchList(interp, B, A);
-            break;
-        default:
-            abort();
-    }
-    Jim_SetResultInt(interp, wC);
-
-    Jim_DecrRefCount(interp, A);
-    Jim_DecrRefCount(interp, B);
-
-    return rc;
-}
-
-static int ExprBool(Jim_Interp *interp, Jim_Obj *obj)
-{
-    long l;
-    double d;
-    int b;
-    int ret = -1;
-
-
-    Jim_IncrRefCount(obj);
-
-    if (Jim_GetLong(interp, obj, &l) == JIM_OK) {
-        ret = (l != 0);
-    }
-    else if (Jim_GetDouble(interp, obj, &d) == JIM_OK) {
-        ret = (d != 0);
-    }
-    else if (Jim_GetBoolean(interp, obj, &b) == JIM_OK) {
-        ret = (b != 0);
-    }
-
-    Jim_DecrRefCount(interp, obj);
-    return ret;
-}
-
-static int JimExprOpAnd(Jim_Interp *interp, struct JimExprNode *node)
-{
-
-    int result = JimExprGetTermBoolean(interp, node->left);
-
-    if (result == 1) {
-
-        result = JimExprGetTermBoolean(interp, node->right);
-    }
-    if (result == -1) {
-        return JIM_ERR;
-    }
-    Jim_SetResultInt(interp, result);
-    return JIM_OK;
-}
-
-static int JimExprOpOr(Jim_Interp *interp, struct JimExprNode *node)
-{
-
-    int result = JimExprGetTermBoolean(interp, node->left);
-
-    if (result == 0) {
-
-        result = JimExprGetTermBoolean(interp, node->right);
-    }
-    if (result == -1) {
-        return JIM_ERR;
-    }
-    Jim_SetResultInt(interp, result);
-    return JIM_OK;
-}
-
-static int JimExprOpTernary(Jim_Interp *interp, struct JimExprNode *node)
-{
-
-    int result = JimExprGetTermBoolean(interp, node->left);
-
-    if (result == 1) {
-
-        return JimExprEvalTermNode(interp, node->right);
-    }
-    else if (result == 0) {
-
-        return JimExprEvalTermNode(interp, node->ternary);
-    }
-
-    return JIM_ERR;
-}
-
-enum
-{
-    OP_FUNC = 0x0001,
-    OP_RIGHT_ASSOC = 0x0002,
-};
-
-#define OPRINIT_ATTR(N, P, ARITY, F, ATTR) {N, F, P, ARITY, ATTR, sizeof(N) - 1}
-#define OPRINIT(N, P, ARITY, F) OPRINIT_ATTR(N, P, ARITY, F, 0)
-
-static const struct Jim_ExprOperator Jim_ExprOperators[] = {
-    OPRINIT("*", 110, 2, JimExprOpBin),
-    OPRINIT("/", 110, 2, JimExprOpBin),
-    OPRINIT("%", 110, 2, JimExprOpIntBin),
-
-    OPRINIT("-", 100, 2, JimExprOpBin),
-    OPRINIT("+", 100, 2, JimExprOpBin),
-
-    OPRINIT("<<", 90, 2, JimExprOpIntBin),
-    OPRINIT(">>", 90, 2, JimExprOpIntBin),
-
-    OPRINIT("<<<", 90, 2, JimExprOpIntBin),
-    OPRINIT(">>>", 90, 2, JimExprOpIntBin),
-
-    OPRINIT("<", 80, 2, JimExprOpBin),
-    OPRINIT(">", 80, 2, JimExprOpBin),
-    OPRINIT("<=", 80, 2, JimExprOpBin),
-    OPRINIT(">=", 80, 2, JimExprOpBin),
-
-    OPRINIT("==", 70, 2, JimExprOpBin),
-    OPRINIT("!=", 70, 2, JimExprOpBin),
-
-    OPRINIT("&", 50, 2, JimExprOpIntBin),
-    OPRINIT("^", 49, 2, JimExprOpIntBin),
-    OPRINIT("|", 48, 2, JimExprOpIntBin),
-
-    OPRINIT("&&", 10, 2, JimExprOpAnd),
-    OPRINIT("||", 9, 2, JimExprOpOr),
-    OPRINIT_ATTR("?", 5, 3, JimExprOpTernary, OP_RIGHT_ASSOC),
-    OPRINIT_ATTR(":", 5, 3, NULL, OP_RIGHT_ASSOC),
-
-
-    OPRINIT_ATTR("**", 120, 2, JimExprOpBin, OP_RIGHT_ASSOC),
-
-    OPRINIT("eq", 60, 2, JimExprOpStrBin),
-    OPRINIT("ne", 60, 2, JimExprOpStrBin),
-
-    OPRINIT("in", 55, 2, JimExprOpStrBin),
-    OPRINIT("ni", 55, 2, JimExprOpStrBin),
-
-    OPRINIT("lt", 75, 2, JimExprOpStrBin),
-    OPRINIT("gt", 75, 2, JimExprOpStrBin),
-    OPRINIT("le", 75, 2, JimExprOpStrBin),
-    OPRINIT("ge", 75, 2, JimExprOpStrBin),
-
-    OPRINIT_ATTR("!", 150, 1, JimExprOpNumUnary, OP_RIGHT_ASSOC),
-    OPRINIT_ATTR("~", 150, 1, JimExprOpIntUnary, OP_RIGHT_ASSOC),
-    OPRINIT_ATTR(" -", 150, 1, JimExprOpNumUnary, OP_RIGHT_ASSOC),
-    OPRINIT_ATTR(" +", 150, 1, JimExprOpNumUnary, OP_RIGHT_ASSOC),
-
-
-
-    OPRINIT_ATTR("int", 200, 1, JimExprOpNumUnary, OP_FUNC),
-    OPRINIT_ATTR("wide", 200, 1, JimExprOpNumUnary, OP_FUNC),
-    OPRINIT_ATTR("abs", 200, 1, JimExprOpNumUnary, OP_FUNC),
-    OPRINIT_ATTR("double", 200, 1, JimExprOpNumUnary, OP_FUNC),
-    OPRINIT_ATTR("round", 200, 1, JimExprOpNumUnary, OP_FUNC),
-    OPRINIT_ATTR("rand", 200, 0, JimExprOpNone, OP_FUNC),
-    OPRINIT_ATTR("srand", 200, 1, JimExprOpIntUnary, OP_FUNC),
-
-#ifdef JIM_MATH_FUNCTIONS
-    OPRINIT_ATTR("sin", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("cos", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("tan", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("asin", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("acos", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("atan", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("atan2", 200, 2, JimExprOpBin, OP_FUNC),
-    OPRINIT_ATTR("sinh", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("cosh", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("tanh", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("ceil", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("floor", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("exp", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("log", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("log10", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("sqrt", 200, 1, JimExprOpDoubleUnary, OP_FUNC),
-    OPRINIT_ATTR("pow", 200, 2, JimExprOpBin, OP_FUNC),
-    OPRINIT_ATTR("hypot", 200, 2, JimExprOpBin, OP_FUNC),
-    OPRINIT_ATTR("fmod", 200, 2, JimExprOpBin, OP_FUNC),
-#endif
-};
-#undef OPRINIT
-#undef OPRINIT_ATTR
-
-#define JIM_EXPR_OPERATORS_NUM \
-    (sizeof(Jim_ExprOperators)/sizeof(struct Jim_ExprOperator))
-
-static int JimParseExpression(struct JimParserCtx *pc)
-{
-    pc->errmsg = NULL;
-
-    while (1) {
-
-        while (isspace(UCHAR(*pc->p)) || (*(pc->p) == '\\' && *(pc->p + 1) == '\n')) {
-            if (*pc->p == '\n') {
-                pc->linenr++;
-            }
-            pc->p++;
-            pc->len--;
-        }
-
-        if (*pc->p == '#') {
-            JimParseComment(pc);
-
-            continue;
-        }
-        break;
-    }
-
-
-    pc->tline = pc->linenr;
-    pc->tstart = pc->p;
-
-    if (pc->len == 0) {
-        pc->tend = pc->p;
-        pc->tt = JIM_TT_EOL;
-        pc->eof = 1;
-        return JIM_OK;
-    }
-    switch (*(pc->p)) {
-        case '(':
-                pc->tt = JIM_TT_SUBEXPR_START;
-                goto singlechar;
-        case ')':
-                pc->tt = JIM_TT_SUBEXPR_END;
-                goto singlechar;
-        case ',':
-            pc->tt = JIM_TT_SUBEXPR_COMMA;
-singlechar:
-            pc->tend = pc->p;
-            pc->p++;
-            pc->len--;
-            break;
-        case '[':
-            return JimParseCmd(pc);
-        case '$':
-            if (JimParseVar(pc) == JIM_ERR)
-                return JimParseExprOperator(pc);
-            else {
-
-                if (pc->tt == JIM_TT_EXPRSUGAR) {
-                    pc->errmsg = "nesting expr in expr is not allowed";
-                    return JIM_ERR;
-                }
-                return JIM_OK;
-            }
-            break;
-        case '0':
-        case '1':
-        case '2':
-        case '3':
-        case '4':
-        case '5':
-        case '6':
-        case '7':
-        case '8':
-        case '9':
-        case '.':
-            return JimParseExprNumber(pc);
-        case '"':
-            return JimParseQuote(pc);
-        case '{':
-            return JimParseBrace(pc);
-
-        case 'N':
-        case 'I':
-        case 'n':
-        case 'i':
-            if (JimParseExprIrrational(pc) == JIM_ERR)
-                if (JimParseExprBoolean(pc) == JIM_ERR)
-                    return JimParseExprOperator(pc);
-            break;
-        case 't':
-        case 'f':
-        case 'o':
-        case 'y':
-            if (JimParseExprBoolean(pc) == JIM_ERR)
-                return JimParseExprOperator(pc);
-            break;
-        default:
-            return JimParseExprOperator(pc);
-            break;
-    }
-    return JIM_OK;
-}
-
-static int JimParseExprNumber(struct JimParserCtx *pc)
-{
-    char *end;
-
-
-    pc->tt = JIM_TT_EXPR_INT;
-
-    jim_strtoull(pc->p, (char **)&pc->p);
-
-    if (strchr("eENnIi.", *pc->p) || pc->p == pc->tstart) {
-        if (strtod(pc->tstart, &end)) { }
-        if (end == pc->tstart)
-            return JIM_ERR;
-        if (end > pc->p) {
-
-            pc->tt = JIM_TT_EXPR_DOUBLE;
-            pc->p = end;
-        }
-    }
-    pc->tend = pc->p - 1;
-    pc->len -= (pc->p - pc->tstart);
-    return JIM_OK;
-}
-
-static int JimParseExprIrrational(struct JimParserCtx *pc)
-{
-    const char *irrationals[] = { "NaN", "nan", "NAN", "Inf", "inf", "INF", NULL };
-    int i;
-
-    for (i = 0; irrationals[i]; i++) {
-        const char *irr = irrationals[i];
-
-        if (strncmp(irr, pc->p, 3) == 0) {
-            pc->p += 3;
-            pc->len -= 3;
-            pc->tend = pc->p - 1;
-            pc->tt = JIM_TT_EXPR_DOUBLE;
-            return JIM_OK;
-        }
-    }
-    return JIM_ERR;
-}
-
-static int JimParseExprBoolean(struct JimParserCtx *pc)
-{
-    int i;
-    for (i = 0; i < sizeof(jim_true_false_strings) / sizeof(*jim_true_false_strings); i++) {
-        if (strncmp(pc->p, jim_true_false_strings[i], jim_true_false_lens[i]) == 0) {
-            pc->p += jim_true_false_lens[i];
-            pc->len -= jim_true_false_lens[i];
-            pc->tend = pc->p - 1;
-            pc->tt = JIM_TT_EXPR_BOOLEAN;
-            return JIM_OK;
-        }
-    }
-    return JIM_ERR;
-}
-
-static const struct Jim_ExprOperator *JimExprOperatorInfoByOpcode(int opcode)
-{
-    static Jim_ExprOperator dummy_op;
-    if (opcode < JIM_TT_EXPR_OP) {
-        return &dummy_op;
-    }
-    return &Jim_ExprOperators[opcode - JIM_TT_EXPR_OP];
-}
-
-static int JimParseExprOperator(struct JimParserCtx *pc)
-{
-    int i;
-    const struct Jim_ExprOperator *bestOp = NULL;
-    int bestLen = 0;
-
-
-    for (i = 0; i < (signed)JIM_EXPR_OPERATORS_NUM; i++) {
-        const struct Jim_ExprOperator *op = &Jim_ExprOperators[i];
-
-        if (op->name[0] != pc->p[0]) {
-            continue;
-        }
-
-        if (op->namelen > bestLen && strncmp(op->name, pc->p, op->namelen) == 0) {
-            bestOp = op;
-            bestLen = op->namelen;
-        }
-    }
-    if (bestOp == NULL) {
-        return JIM_ERR;
-    }
-
-
-    if (bestOp->attr & OP_FUNC) {
-        const char *p = pc->p + bestLen;
-        int len = pc->len - bestLen;
-
-        while (len && isspace(UCHAR(*p))) {
-            len--;
-            p++;
-        }
-        if (*p != '(') {
-            pc->errmsg = "function requires parentheses";
-            return JIM_ERR;
-        }
-    }
-    pc->tend = pc->p + bestLen - 1;
-    pc->p += bestLen;
-    pc->len -= bestLen;
-
-    pc->tt = (bestOp - Jim_ExprOperators) + JIM_TT_EXPR_OP;
-    return JIM_OK;
-}
-
-
-static void FreeExprInternalRep(Jim_Interp *interp, Jim_Obj *objPtr);
-static void DupExprInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
-static int SetExprFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
-
-static const Jim_ObjType exprObjType = {
-    "expression",
-    FreeExprInternalRep,
-    DupExprInternalRep,
-    NULL,
-    JIM_TYPE_NONE,
-};
-
-
-struct ExprTree
-{
-    struct JimExprNode *expr;
-    struct JimExprNode *nodes;
-    int len;
-    int inUse;
-};
-
-static void ExprTreeFreeNodes(Jim_Interp *interp, struct JimExprNode *nodes, int num)
-{
-    int i;
-    for (i = 0; i < num; i++) {
-        if (nodes[i].objPtr) {
-            Jim_DecrRefCount(interp, nodes[i].objPtr);
-        }
-    }
-    Jim_Free(nodes);
-}
-
-static void ExprTreeFree(Jim_Interp *interp, struct ExprTree *expr)
-{
-    ExprTreeFreeNodes(interp, expr->nodes, expr->len);
-    Jim_Free(expr);
-}
-
-static void FreeExprInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    struct ExprTree *expr = (void *)objPtr->internalRep.ptr;
-
-    if (expr) {
-        if (--expr->inUse != 0) {
-            return;
-        }
-
-        ExprTreeFree(interp, expr);
-    }
-}
-
-static void DupExprInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
-{
-    JIM_NOTUSED(interp);
-    JIM_NOTUSED(srcPtr);
-
-
-    dupPtr->typePtr = NULL;
-}
-
-struct ExprBuilder {
-    int parencount;
-    int level;
-    ParseToken *token;
-    ParseToken *first_token;
-    Jim_Stack stack;
-    Jim_Obj *exprObjPtr;
-    Jim_Obj *fileNameObj;
-    struct JimExprNode *nodes;
-    struct JimExprNode *next;
-};
-
-#ifdef DEBUG_SHOW_EXPR
-static void JimShowExprNode(struct JimExprNode *node, int level)
-{
-    int i;
-    for (i = 0; i < level; i++) {
-        printf("  ");
-    }
-    if (TOKEN_IS_EXPR_OP(node->type)) {
-        printf("%s\n", jim_tt_name(node->type));
-        if (node->left) {
-            JimShowExprNode(node->left, level + 1);
-        }
-        if (node->right) {
-            JimShowExprNode(node->right, level + 1);
-        }
-        if (node->ternary) {
-            JimShowExprNode(node->ternary, level + 1);
-        }
-    }
-    else {
-        printf("[%s] %s\n", jim_tt_name(node->type), Jim_String(node->objPtr));
-    }
-}
-#endif
-
-#define EXPR_UNTIL_CLOSE 0x0001
-#define EXPR_FUNC_ARGS   0x0002
-#define EXPR_TERNARY     0x0004
-
-static int ExprTreeBuildTree(Jim_Interp *interp, struct ExprBuilder *builder, int precedence, int flags, int exp_numterms) {
-    int rc;
-    struct JimExprNode *node;
-
-    int exp_stacklen = builder->stack.len + exp_numterms;
-
-    if (builder->level++ > 200) {
-        Jim_SetResultString(interp, "Expression too complex", -1);
-        return JIM_ERR;
-    }
-
-    while (builder->token->type != JIM_TT_EOL) {
-        ParseToken *t = builder->token++;
-        int prevtt;
-
-        if (t == builder->first_token) {
-            prevtt = JIM_TT_NONE;
-        }
-        else {
-            prevtt = t[-1].type;
-        }
-
-        if (t->type == JIM_TT_SUBEXPR_START) {
-            if (builder->stack.len == exp_stacklen) {
-                Jim_SetResultFormatted(interp, "unexpected open parenthesis in expression: \"%#s\"", builder->exprObjPtr);
-                return JIM_ERR;
-            }
-            builder->parencount++;
-            rc = ExprTreeBuildTree(interp, builder, 0, EXPR_UNTIL_CLOSE, 1);
-            if (rc != JIM_OK) {
-                return rc;
-            }
-
-        }
-        else if (t->type == JIM_TT_SUBEXPR_END) {
-            if (!(flags & EXPR_UNTIL_CLOSE)) {
-                if (builder->stack.len == exp_stacklen && builder->level > 1) {
-                    builder->token--;
-                    builder->level--;
-                    return JIM_OK;
-                }
-                Jim_SetResultFormatted(interp, "unexpected closing parenthesis in expression: \"%#s\"", builder->exprObjPtr);
-                return JIM_ERR;
-            }
-            builder->parencount--;
-            if (builder->stack.len == exp_stacklen) {
-
-                break;
-            }
-        }
-        else if (t->type == JIM_TT_SUBEXPR_COMMA) {
-            if (!(flags & EXPR_FUNC_ARGS)) {
-                if (builder->stack.len == exp_stacklen) {
-
-                    builder->token--;
-                    builder->level--;
-                    return JIM_OK;
-                }
-                Jim_SetResultFormatted(interp, "unexpected comma in expression: \"%#s\"", builder->exprObjPtr);
-                return JIM_ERR;
-            }
-            else {
-
-                if (builder->stack.len > exp_stacklen) {
-                    Jim_SetResultFormatted(interp, "too many arguments to math function");
-                    return JIM_ERR;
-                }
-            }
-
-        }
-        else if (t->type == JIM_EXPROP_COLON) {
-            if (!(flags & EXPR_TERNARY)) {
-                if (builder->level != 1) {
-
-                    builder->token--;
-                    builder->level--;
-                    return JIM_OK;
-                }
-                Jim_SetResultFormatted(interp, ": without ? in expression: \"%#s\"", builder->exprObjPtr);
-                return JIM_ERR;
-            }
-            if (builder->stack.len == exp_stacklen) {
-
-                builder->token--;
-                builder->level--;
-                return JIM_OK;
-            }
-
-        }
-        else if (TOKEN_IS_EXPR_OP(t->type)) {
-            const struct Jim_ExprOperator *op;
-
-
-            if (TOKEN_IS_EXPR_OP(prevtt) || TOKEN_IS_EXPR_START(prevtt)) {
-                if (t->type == JIM_EXPROP_SUB) {
-                    t->type = JIM_EXPROP_UNARYMINUS;
-                }
-                else if (t->type == JIM_EXPROP_ADD) {
-                    t->type = JIM_EXPROP_UNARYPLUS;
-                }
-            }
-
-            op = JimExprOperatorInfoByOpcode(t->type);
-
-            if (op->precedence < precedence || (!(op->attr & OP_RIGHT_ASSOC) && op->precedence == precedence)) {
-
-                builder->token--;
-                break;
-            }
-
-            if (op->attr & OP_FUNC) {
-                if (builder->token->type != JIM_TT_SUBEXPR_START) {
-                    Jim_SetResultString(interp, "missing arguments for math function", -1);
-                    return JIM_ERR;
-                }
-                builder->token++;
-                if (op->arity == 0) {
-                    if (builder->token->type != JIM_TT_SUBEXPR_END) {
-                        Jim_SetResultString(interp, "too many arguments for math function", -1);
-                        return JIM_ERR;
-                    }
-                    builder->token++;
-                    goto noargs;
-                }
-                builder->parencount++;
-
-
-                rc = ExprTreeBuildTree(interp, builder, 0, EXPR_FUNC_ARGS | EXPR_UNTIL_CLOSE, op->arity);
-            }
-            else if (t->type == JIM_EXPROP_TERNARY) {
-
-                rc = ExprTreeBuildTree(interp, builder, op->precedence, EXPR_TERNARY, 2);
-            }
-            else {
-                rc = ExprTreeBuildTree(interp, builder, op->precedence, 0, 1);
-            }
-
-            if (rc != JIM_OK) {
-                return rc;
-            }
-
-noargs:
-            node = builder->next++;
-            node->type = t->type;
-
-            if (op->arity >= 3) {
-                node->ternary = Jim_StackPop(&builder->stack);
-                if (node->ternary == NULL) {
-                    goto missingoperand;
-                }
-            }
-            if (op->arity >= 2) {
-                node->right = Jim_StackPop(&builder->stack);
-                if (node->right == NULL) {
-                    goto missingoperand;
-                }
-            }
-            if (op->arity >= 1) {
-                node->left = Jim_StackPop(&builder->stack);
-                if (node->left == NULL) {
-missingoperand:
-                    Jim_SetResultFormatted(interp, "missing operand to %s in expression: \"%#s\"", op->name, builder->exprObjPtr);
-                    builder->next--;
-                    return JIM_ERR;
-
-                }
-            }
-
-
-            Jim_StackPush(&builder->stack, node);
-        }
-        else {
-            Jim_Obj *objPtr = NULL;
-
-
-
-
-            if (!TOKEN_IS_EXPR_START(prevtt) && !TOKEN_IS_EXPR_OP(prevtt)) {
-                Jim_SetResultFormatted(interp, "missing operator in expression: \"%#s\"", builder->exprObjPtr);
-                return JIM_ERR;
-            }
-
-
-            if (t->type == JIM_TT_EXPR_INT || t->type == JIM_TT_EXPR_DOUBLE) {
-                char *endptr;
-                if (t->type == JIM_TT_EXPR_INT) {
-                    objPtr = Jim_NewIntObj(interp, jim_strtoull(t->token, &endptr));
-                }
-                else {
-                    objPtr = Jim_NewDoubleObj(interp, strtod(t->token, &endptr));
-                }
-                if (endptr != t->token + t->len) {
-
-                    Jim_FreeNewObj(interp, objPtr);
-                    objPtr = NULL;
-                }
-            }
-
-            if (!objPtr) {
-
-                objPtr = Jim_NewStringObj(interp, t->token, t->len);
-                if (t->type == JIM_TT_CMD) {
-
-                    Jim_SetSourceInfo(interp, objPtr, builder->fileNameObj, t->line);
-                }
-            }
-
-
-            node = builder->next++;
-            node->objPtr = objPtr;
-            Jim_IncrRefCount(node->objPtr);
-            node->type = t->type;
-            Jim_StackPush(&builder->stack, node);
-        }
-    }
-
-    if (builder->stack.len == exp_stacklen) {
-        builder->level--;
-        return JIM_OK;
-    }
-
-    if ((flags & EXPR_FUNC_ARGS)) {
-        Jim_SetResultFormatted(interp, "too %s arguments for math function", (builder->stack.len < exp_stacklen) ? "few" : "many");
-    }
-    else {
-        if (builder->stack.len < exp_stacklen) {
-            if (builder->level == 0) {
-                Jim_SetResultFormatted(interp, "empty expression");
-            }
-            else {
-                Jim_SetResultFormatted(interp, "syntax error in expression \"%#s\": premature end of expression", builder->exprObjPtr);
-            }
-        }
-        else {
-            Jim_SetResultFormatted(interp, "extra terms after expression");
-        }
-    }
-
-    return JIM_ERR;
-}
-
-static struct ExprTree *ExprTreeCreateTree(Jim_Interp *interp, const ParseTokenList *tokenlist, Jim_Obj *exprObjPtr, Jim_Obj *fileNameObj)
-{
-    struct ExprTree *expr;
-    struct ExprBuilder builder;
-    int rc;
-    struct JimExprNode *top = NULL;
-
-    builder.parencount = 0;
-    builder.level = 0;
-    builder.token = builder.first_token = tokenlist->list;
-    builder.exprObjPtr = exprObjPtr;
-    builder.fileNameObj = fileNameObj;
-
-    builder.nodes = Jim_Alloc(sizeof(struct JimExprNode) * (tokenlist->count - 1));
-    memset(builder.nodes, 0, sizeof(struct JimExprNode) * (tokenlist->count - 1));
-    builder.next = builder.nodes;
-    Jim_InitStack(&builder.stack);
-
-    rc = ExprTreeBuildTree(interp, &builder, 0, 0, 1);
-
-    if (rc == JIM_OK) {
-        top = Jim_StackPop(&builder.stack);
-
-        if (builder.parencount) {
-            Jim_SetResultString(interp, "missing close parenthesis", -1);
-            rc = JIM_ERR;
-        }
-    }
-
-
-    Jim_FreeStack(&builder.stack);
-
-    if (rc != JIM_OK) {
-        ExprTreeFreeNodes(interp, builder.nodes, builder.next - builder.nodes);
-        return NULL;
-    }
-
-    expr = Jim_Alloc(sizeof(*expr));
-    expr->inUse = 1;
-    expr->expr = top;
-    expr->nodes = builder.nodes;
-    expr->len = builder.next - builder.nodes;
-
-    assert(expr->len <= tokenlist->count - 1);
-
-    return expr;
-}
-
-static int SetExprFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
-{
-    int exprTextLen;
-    const char *exprText;
-    struct JimParserCtx parser;
-    struct ExprTree *expr;
-    ParseTokenList tokenlist;
-    int line;
-    Jim_Obj *fileNameObj;
-    int rc = JIM_ERR;
-
-
-    fileNameObj = Jim_GetSourceInfo(interp, objPtr, &line);
-    Jim_IncrRefCount(fileNameObj);
-
-    exprText = Jim_GetString(objPtr, &exprTextLen);
-
-
-    ScriptTokenListInit(&tokenlist);
-
-    JimParserInit(&parser, exprText, exprTextLen, line);
-    while (!parser.eof) {
-        if (JimParseExpression(&parser) != JIM_OK) {
-            ScriptTokenListFree(&tokenlist);
-            Jim_SetResultFormatted(interp, "syntax error in expression: \"%#s\"", objPtr);
-            if (parser.errmsg) {
-                Jim_AppendStrings(interp, Jim_GetResult(interp), ": ", parser.errmsg, NULL);
-            }
-            expr = NULL;
-            goto err;
-        }
-
-        ScriptAddToken(&tokenlist, parser.tstart, parser.tend - parser.tstart + 1, parser.tt,
-            parser.tline);
-    }
-
-#ifdef DEBUG_SHOW_EXPR_TOKENS
-    {
-        int i;
-        printf("==== Expr Tokens (%s) ====\n", Jim_String(fileNameObj));
-        for (i = 0; i < tokenlist.count; i++) {
-            printf("[%2d]@%d %s '%.*s'\n", i, tokenlist.list[i].line, jim_tt_name(tokenlist.list[i].type),
-                tokenlist.list[i].len, tokenlist.list[i].token);
-        }
-    }
-#endif
-
-    if (tokenlist.count <= 1) {
-        Jim_SetResultString(interp, "empty expression", -1);
-        rc = JIM_ERR;
-    }
-    else {
-        rc = JimParseCheckMissing(interp, parser.missing.ch);
-    }
-    if (rc != JIM_OK) {
-        ScriptTokenListFree(&tokenlist);
-        Jim_DecrRefCount(interp, fileNameObj);
-        return rc;
-    }
-
-
-    expr = ExprTreeCreateTree(interp, &tokenlist, objPtr, fileNameObj);
-
-
-    ScriptTokenListFree(&tokenlist);
-
-    if (!expr) {
-        goto err;
-    }
-
-#ifdef DEBUG_SHOW_EXPR
-    printf("==== Expr ====\n");
-    JimShowExprNode(expr->expr, 0);
-#endif
-
-    rc = JIM_OK;
-
-  err:
-
-    Jim_DecrRefCount(interp, fileNameObj);
-    Jim_FreeIntRep(interp, objPtr);
-    Jim_SetIntRepPtr(objPtr, expr);
-    objPtr->typePtr = &exprObjType;
-    return rc;
-}
-
-static struct ExprTree *JimGetExpression(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    if (objPtr->typePtr != &exprObjType) {
-        if (SetExprFromAny(interp, objPtr) != JIM_OK) {
-            return NULL;
-        }
-    }
-    return (struct ExprTree *) Jim_GetIntRepPtr(objPtr);
-}
-
-#ifdef JIM_OPTIMIZATION
-static Jim_Obj *JimExprIntValOrVar(Jim_Interp *interp, struct JimExprNode *node)
-{
-    if (node->type == JIM_TT_EXPR_INT)
-        return node->objPtr;
-    else if (node->type == JIM_TT_VAR)
-        return Jim_GetVariable(interp, node->objPtr, JIM_NONE);
-    else if (node->type == JIM_TT_DICTSUGAR)
-        return JimExpandDictSugar(interp, node->objPtr);
-    else
-        return NULL;
-}
-#endif
-
-
-static int JimExprEvalTermNode(Jim_Interp *interp, struct JimExprNode *node)
-{
-    if (TOKEN_IS_EXPR_OP(node->type)) {
-        const struct Jim_ExprOperator *op = JimExprOperatorInfoByOpcode(node->type);
-        return op->funcop(interp, node);
-    }
-    else {
-        Jim_Obj *objPtr;
-
-
-        switch (node->type) {
-            case JIM_TT_EXPR_INT:
-            case JIM_TT_EXPR_DOUBLE:
-            case JIM_TT_EXPR_BOOLEAN:
-            case JIM_TT_STR:
-                Jim_SetResult(interp, node->objPtr);
-                return JIM_OK;
-
-            case JIM_TT_VAR:
-                objPtr = Jim_GetVariable(interp, node->objPtr, JIM_ERRMSG);
-                if (objPtr) {
-                    Jim_SetResult(interp, objPtr);
-                    return JIM_OK;
-                }
-                return JIM_ERR;
-
-            case JIM_TT_DICTSUGAR:
-                objPtr = JimExpandDictSugar(interp, node->objPtr);
-                if (objPtr) {
-                    Jim_SetResult(interp, objPtr);
-                    return JIM_OK;
-                }
-                return JIM_ERR;
-
-            case JIM_TT_ESC:
-                if (interp->safeexpr) {
-                    return JIM_ERR;
-                }
-                if (Jim_SubstObj(interp, node->objPtr, &objPtr, JIM_NONE) == JIM_OK) {
-                    Jim_SetResult(interp, objPtr);
-                    return JIM_OK;
-                }
-                return JIM_ERR;
-
-            case JIM_TT_CMD:
-                if (interp->safeexpr) {
-                    return JIM_ERR;
-                }
-                return Jim_EvalObj(interp, node->objPtr);
-
-            default:
-
-                return JIM_ERR;
-        }
-    }
-}
-
-static int JimExprGetTerm(Jim_Interp *interp, struct JimExprNode *node, Jim_Obj **objPtrPtr)
-{
-    int rc = JimExprEvalTermNode(interp, node);
-    if (rc == JIM_OK) {
-        *objPtrPtr = Jim_GetResult(interp);
-        Jim_IncrRefCount(*objPtrPtr);
-    }
-    return rc;
-}
-
-static int JimExprGetTermBoolean(Jim_Interp *interp, struct JimExprNode *node)
-{
-    if (JimExprEvalTermNode(interp, node) == JIM_OK) {
-        return ExprBool(interp, Jim_GetResult(interp));
-    }
-    return -1;
-}
-
-int Jim_EvalExpression(Jim_Interp *interp, Jim_Obj *exprObjPtr)
-{
-    struct ExprTree *expr;
-    int retcode = JIM_OK;
-
-    Jim_IncrRefCount(exprObjPtr);
-    expr = JimGetExpression(interp, exprObjPtr);
-    if (!expr) {
-        retcode = JIM_ERR;
-        goto done;
-    }
-
-#ifdef JIM_OPTIMIZATION
-    if (!interp->safeexpr) {
-        Jim_Obj *objPtr;
-
-
-        switch (expr->len) {
-            case 1:
-                objPtr = JimExprIntValOrVar(interp, expr->expr);
-                if (objPtr) {
-                    Jim_SetResult(interp, objPtr);
-                    goto done;
-                }
-                break;
-
-            case 2:
-                if (expr->expr->type == JIM_EXPROP_NOT) {
-                    objPtr = JimExprIntValOrVar(interp, expr->expr->left);
-
-                    if (objPtr && JimIsWide(objPtr)) {
-                        Jim_SetResult(interp, JimWideValue(objPtr) ? interp->falseObj : interp->trueObj);
-                        goto done;
-                    }
-                }
-                break;
-
-            case 3:
-                objPtr = JimExprIntValOrVar(interp, expr->expr->left);
-                if (objPtr && JimIsWide(objPtr)) {
-                    Jim_Obj *objPtr2 = JimExprIntValOrVar(interp, expr->expr->right);
-                    if (objPtr2 && JimIsWide(objPtr2)) {
-                        jim_wide wideValueA = JimWideValue(objPtr);
-                        jim_wide wideValueB = JimWideValue(objPtr2);
-                        int cmpRes;
-                        switch (expr->expr->type) {
-                            case JIM_EXPROP_LT:
-                                cmpRes = wideValueA < wideValueB;
-                                break;
-                            case JIM_EXPROP_LTE:
-                                cmpRes = wideValueA <= wideValueB;
-                                break;
-                            case JIM_EXPROP_GT:
-                                cmpRes = wideValueA > wideValueB;
-                                break;
-                            case JIM_EXPROP_GTE:
-                                cmpRes = wideValueA >= wideValueB;
-                                break;
-                            case JIM_EXPROP_NUMEQ:
-                                cmpRes = wideValueA == wideValueB;
-                                break;
-                            case JIM_EXPROP_NUMNE:
-                                cmpRes = wideValueA != wideValueB;
-                                break;
-                            default:
-                                goto noopt;
-                        }
-                        Jim_SetResult(interp, cmpRes ? interp->trueObj : interp->falseObj);
-                        goto done;
-                    }
-                }
-                break;
-        }
-    }
-noopt:
-#endif
-
-    expr->inUse++;
-
-
-    retcode = JimExprEvalTermNode(interp, expr->expr);
-
-
-    Jim_FreeIntRep(interp, exprObjPtr);
-    exprObjPtr->typePtr = &exprObjType;
-    Jim_SetIntRepPtr(exprObjPtr, expr);
-
-done:
-    Jim_DecrRefCount(interp, exprObjPtr);
-
-    return retcode;
-}
-
-int Jim_GetBoolFromExpr(Jim_Interp *interp, Jim_Obj *exprObjPtr, int *boolPtr)
-{
-    int retcode = Jim_EvalExpression(interp, exprObjPtr);
-
-    if (retcode == JIM_OK) {
-        switch (ExprBool(interp, Jim_GetResult(interp))) {
-            case 0:
-                *boolPtr = 0;
-                break;
-
-            case 1:
-                *boolPtr = 1;
-                break;
-
-            case -1:
-                retcode = JIM_ERR;
-                break;
-        }
-    }
-    return retcode;
-}
-
-
-
-
-typedef struct ScanFmtPartDescr
-{
-    const char *arg;
-    const char *prefix;
-    size_t width;
-    int pos;
-    char type;
-    char modifier;
-} ScanFmtPartDescr;
-
-
-typedef struct ScanFmtStringObj
-{
-    jim_wide size;
-    char *stringRep;
-    size_t count;
-    size_t convCount;
-    size_t maxPos;
-    const char *error;
-    char *scratch;
-    ScanFmtPartDescr descr[1];
-} ScanFmtStringObj;
-
-
-static void FreeScanFmtInternalRep(Jim_Interp *interp, Jim_Obj *objPtr);
-static void DupScanFmtInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
-static void UpdateStringOfScanFmt(Jim_Obj *objPtr);
-
-static const Jim_ObjType scanFmtStringObjType = {
-    "scanformatstring",
-    FreeScanFmtInternalRep,
-    DupScanFmtInternalRep,
-    UpdateStringOfScanFmt,
-    JIM_TYPE_NONE,
-};
-
-void FreeScanFmtInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    JIM_NOTUSED(interp);
-    Jim_Free((char *)objPtr->internalRep.ptr);
-    objPtr->internalRep.ptr = 0;
-}
-
-void DupScanFmtInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
-{
-    size_t size = (size_t) ((ScanFmtStringObj *) srcPtr->internalRep.ptr)->size;
-    ScanFmtStringObj *newVec = (ScanFmtStringObj *) Jim_Alloc(size);
-
-    JIM_NOTUSED(interp);
-    memcpy(newVec, srcPtr->internalRep.ptr, size);
-    dupPtr->internalRep.ptr = newVec;
-    dupPtr->typePtr = &scanFmtStringObjType;
-}
-
-static void UpdateStringOfScanFmt(Jim_Obj *objPtr)
-{
-    JimSetStringBytes(objPtr, ((ScanFmtStringObj *) objPtr->internalRep.ptr)->stringRep);
-}
-
-
-static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    ScanFmtStringObj *fmtObj;
-    char *buffer;
-    int maxCount, i, approxSize, lastPos = -1;
-    const char *fmt = Jim_String(objPtr);
-    int maxFmtLen = Jim_Length(objPtr);
-    const char *fmtEnd = fmt + maxFmtLen;
-    int curr;
-
-    Jim_FreeIntRep(interp, objPtr);
-
-    for (i = 0, maxCount = 0; i < maxFmtLen; ++i)
-        if (fmt[i] == '%')
-            ++maxCount;
-
-    approxSize = sizeof(ScanFmtStringObj)
-        +(maxCount + 1) * sizeof(ScanFmtPartDescr)
-        +maxFmtLen * sizeof(char) + 3 + 1
-        + maxFmtLen * sizeof(char) + 1
-        + maxFmtLen * sizeof(char)
-        +(maxCount + 1) * sizeof(char)
-        +1;
-    fmtObj = (ScanFmtStringObj *) Jim_Alloc(approxSize);
-    memset(fmtObj, 0, approxSize);
-    fmtObj->size = approxSize;
-    fmtObj->maxPos = 0;
-    fmtObj->scratch = (char *)&fmtObj->descr[maxCount + 1];
-    fmtObj->stringRep = fmtObj->scratch + maxFmtLen + 3 + 1;
-    memcpy(fmtObj->stringRep, fmt, maxFmtLen);
-    buffer = fmtObj->stringRep + maxFmtLen + 1;
-    objPtr->internalRep.ptr = fmtObj;
-    objPtr->typePtr = &scanFmtStringObjType;
-    for (i = 0, curr = 0; fmt < fmtEnd; ++fmt) {
-        int width = 0, skip;
-        ScanFmtPartDescr *descr = &fmtObj->descr[curr];
-
-        fmtObj->count++;
-        descr->width = 0;
-
-        if (*fmt != '%' || fmt[1] == '%') {
-            descr->type = 0;
-            descr->prefix = &buffer[i];
-            for (; fmt < fmtEnd; ++fmt) {
-                if (*fmt == '%') {
-                    if (fmt[1] != '%')
-                        break;
-                    ++fmt;
-                }
-                buffer[i++] = *fmt;
-            }
-            buffer[i++] = 0;
-        }
-
-        ++fmt;
-
-        if (fmt >= fmtEnd)
-            goto done;
-        descr->pos = 0;
-        if (*fmt == '*') {
-            descr->pos = -1;
-            ++fmt;
-        }
-        else
-            fmtObj->convCount++;
-
-        if (sscanf(fmt, "%d%n", &width, &skip) == 1) {
-            fmt += skip;
-
-            if (descr->pos != -1 && *fmt == '$') {
-                int prev;
-
-                ++fmt;
-                descr->pos = width;
-                width = 0;
-
-                if ((lastPos == 0 && descr->pos > 0)
-                    || (lastPos > 0 && descr->pos == 0)) {
-                    fmtObj->error = "cannot mix \"%\" and \"%n$\" conversion specifiers";
-                    return JIM_ERR;
-                }
-
-                for (prev = 0; prev < curr; ++prev) {
-                    if (fmtObj->descr[prev].pos == -1)
-                        continue;
-                    if (fmtObj->descr[prev].pos == descr->pos) {
-                        fmtObj->error =
-                            "variable is assigned by multiple \"%n$\" conversion specifiers";
-                        return JIM_ERR;
-                    }
-                }
-                if (descr->pos < 0) {
-                    fmtObj->error =
-                        "\"%n$\" conversion specifier is negative";
-                    return JIM_ERR;
-                }
-
-                if (sscanf(fmt, "%d%n", &width, &skip) == 1) {
-                    descr->width = width;
-                    fmt += skip;
-                }
-                if (descr->pos > 0 && (size_t) descr->pos > fmtObj->maxPos)
-                    fmtObj->maxPos = descr->pos;
-            }
-            else {
-
-                descr->width = width;
-            }
-        }
-
-        if (lastPos == -1)
-            lastPos = descr->pos;
-
-        if (*fmt == '[') {
-            int swapped = 1, beg = i, end, j;
-
-            descr->type = '[';
-            descr->arg = &buffer[i];
-            ++fmt;
-            if (*fmt == '^')
-                buffer[i++] = *fmt++;
-            if (*fmt == ']')
-                buffer[i++] = *fmt++;
-            while (*fmt && *fmt != ']')
-                buffer[i++] = *fmt++;
-            if (*fmt != ']') {
-                fmtObj->error = "unmatched [ in format string";
-                return JIM_ERR;
-            }
-            end = i;
-            buffer[i++] = 0;
-
-            while (swapped) {
-                swapped = 0;
-                for (j = beg + 1; j < end - 1; ++j) {
-                    if (buffer[j] == '-' && buffer[j - 1] > buffer[j + 1]) {
-                        char tmp = buffer[j - 1];
-
-                        buffer[j - 1] = buffer[j + 1];
-                        buffer[j + 1] = tmp;
-                        swapped = 1;
-                    }
-                }
-            }
-        }
-        else {
-
-            if (fmt < fmtEnd && strchr("hlL", *fmt))
-                descr->modifier = tolower((int)*fmt++);
-
-            if (fmt >= fmtEnd) {
-                fmtObj->error = "missing scan conversion character";
-                return JIM_ERR;
-            }
-
-            descr->type = *fmt;
-            if (strchr("efgcsndoxui", *fmt) == 0) {
-                fmtObj->error = "bad scan conversion character";
-                return JIM_ERR;
-            }
-            else if (*fmt == 'c' && descr->width != 0) {
-                fmtObj->error = "field width may not be specified in %c " "conversion";
-                return JIM_ERR;
-            }
-            else if (*fmt == 'u' && descr->modifier == 'l') {
-                fmtObj->error = "unsigned wide not supported";
-                return JIM_ERR;
-            }
-        }
-        curr++;
-    }
-  done:
-    return JIM_OK;
-}
-
-
-
-#define FormatGetCnvCount(_fo_) \
-    ((ScanFmtStringObj*)((_fo_)->internalRep.ptr))->convCount
-#define FormatGetMaxPos(_fo_) \
-    ((ScanFmtStringObj*)((_fo_)->internalRep.ptr))->maxPos
-#define FormatGetError(_fo_) \
-    ((ScanFmtStringObj*)((_fo_)->internalRep.ptr))->error
-
-static Jim_Obj *JimScanAString(Jim_Interp *interp, const char *sdescr, const char *str)
-{
-    char *buffer = Jim_StrDup(str);
-    char *p = buffer;
-
-    while (*str) {
-        int c;
-        int n;
-
-        if (!sdescr && isspace(UCHAR(*str)))
-            break;
-
-        n = utf8_tounicode(str, &c);
-        if (sdescr && !JimCharsetMatch(sdescr, strlen(sdescr), c, JIM_CHARSET_SCAN))
-            break;
-        while (n--)
-            *p++ = *str++;
-    }
-    *p = 0;
-    return Jim_NewStringObjNoAlloc(interp, buffer, p - buffer);
-}
-
-
-static int ScanOneEntry(Jim_Interp *interp, const char *str, int pos, int str_bytelen,
-    ScanFmtStringObj * fmtObj, long idx, Jim_Obj **valObjPtr)
-{
-    const char *tok;
-    const ScanFmtPartDescr *descr = &fmtObj->descr[idx];
-    size_t scanned = 0;
-    size_t anchor = pos;
-    int i;
-    Jim_Obj *tmpObj = NULL;
-
-
-    *valObjPtr = 0;
-    if (descr->prefix) {
-        for (i = 0; pos < str_bytelen && descr->prefix[i]; ++i) {
-
-            if (isspace(UCHAR(descr->prefix[i])))
-                while (pos < str_bytelen && isspace(UCHAR(str[pos])))
-                    ++pos;
-            else if (descr->prefix[i] != str[pos])
-                break;
-            else
-                ++pos;
-        }
-        if (pos >= str_bytelen) {
-            return -1;
-        }
-        else if (descr->prefix[i] != 0)
-            return 0;
-    }
-
-    if (descr->type != 'c' && descr->type != '[' && descr->type != 'n')
-        while (isspace(UCHAR(str[pos])))
-            ++pos;
-
-
-    scanned = pos - anchor;
-
-
-    if (descr->type == 'n') {
-
-        *valObjPtr = Jim_NewIntObj(interp, anchor + scanned);
-    }
-    else if (pos >= str_bytelen) {
-
-        return -1;
-    }
-    else if (descr->type == 'c') {
-        int c;
-        scanned += utf8_tounicode(&str[pos], &c);
-        *valObjPtr = Jim_NewIntObj(interp, c);
-        return scanned;
-    }
-    else {
-
-        if (descr->width > 0) {
-            size_t sLen = utf8_strlen(&str[pos], str_bytelen - pos);
-            size_t tLen = descr->width > sLen ? sLen : descr->width;
-
-            tmpObj = Jim_NewStringObjUtf8(interp, str + pos, tLen);
-            tok = tmpObj->bytes;
-        }
-        else {
-
-            tok = &str[pos];
-        }
-        switch (descr->type) {
-            case 'd':
-            case 'o':
-            case 'x':
-            case 'u':
-            case 'i':{
-                    char *endp;
-                    jim_wide w;
-
-                    int base = descr->type == 'o' ? 8
-                        : descr->type == 'x' ? 16 : descr->type == 'i' ? 0 : 10;
-
-
-                    if (base == 0) {
-                        w = jim_strtoull(tok, &endp);
-                    }
-                    else {
-                        w = strtoull(tok, &endp, base);
-                    }
-
-                    if (endp != tok) {
-
-                        *valObjPtr = Jim_NewIntObj(interp, w);
-
-
-                        scanned += endp - tok;
-                    }
-                    else {
-                        scanned = *tok ? 0 : -1;
-                    }
-                    break;
-                }
-            case 's':
-            case '[':{
-                    *valObjPtr = JimScanAString(interp, descr->arg, tok);
-                    scanned += Jim_Length(*valObjPtr);
-                    break;
-                }
-            case 'e':
-            case 'f':
-            case 'g':{
-                    char *endp;
-                    double value = strtod(tok, &endp);
-
-                    if (endp != tok) {
-
-                        *valObjPtr = Jim_NewDoubleObj(interp, value);
-
-                        scanned += endp - tok;
-                    }
-                    else {
-                        scanned = *tok ? 0 : -1;
-                    }
-                    break;
-                }
-        }
-        if (tmpObj) {
-            Jim_FreeNewObj(interp, tmpObj);
-        }
-    }
-    return scanned;
-}
-
-
-Jim_Obj *Jim_ScanString(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *fmtObjPtr, int flags)
-{
-    size_t i, pos;
-    int scanned = 1;
-    const char *str = Jim_String(strObjPtr);
-    int str_bytelen = Jim_Length(strObjPtr);
-    Jim_Obj *resultList = 0;
-    Jim_Obj **resultVec = 0;
-    int resultc;
-    Jim_Obj *emptyStr = 0;
-    ScanFmtStringObj *fmtObj;
-
-
-    JimPanic((fmtObjPtr->typePtr != &scanFmtStringObjType, "Jim_ScanString() for non-scan format"));
-
-    fmtObj = (ScanFmtStringObj *) fmtObjPtr->internalRep.ptr;
-
-    if (fmtObj->error != 0) {
-        if (flags & JIM_ERRMSG)
-            Jim_SetResultString(interp, fmtObj->error, -1);
-        return 0;
-    }
-
-    emptyStr = Jim_NewEmptyStringObj(interp);
-    Jim_IncrRefCount(emptyStr);
-
-    resultList = Jim_NewListObj(interp, NULL, 0);
-    if (fmtObj->maxPos > 0) {
-        for (i = 0; i < fmtObj->maxPos; ++i)
-            Jim_ListAppendElement(interp, resultList, emptyStr);
-        JimListGetElements(interp, resultList, &resultc, &resultVec);
-    }
-
-    for (i = 0, pos = 0; i < fmtObj->count; ++i) {
-        ScanFmtPartDescr *descr = &(fmtObj->descr[i]);
-        Jim_Obj *value = 0;
-
-
-        if (descr->type == 0)
-            continue;
-
-        if (scanned > 0)
-            scanned = ScanOneEntry(interp, str, pos, str_bytelen, fmtObj, i, &value);
-
-        if (scanned == -1 && i == 0)
-            goto eof;
-
-        pos += scanned;
-
-
-        if (value == 0)
-            value = Jim_NewEmptyStringObj(interp);
-
-        if (descr->pos == -1) {
-            Jim_FreeNewObj(interp, value);
-        }
-        else if (descr->pos == 0)
-
-            Jim_ListAppendElement(interp, resultList, value);
-        else if (resultVec[descr->pos - 1] == emptyStr) {
-
-            Jim_DecrRefCount(interp, resultVec[descr->pos - 1]);
-            Jim_IncrRefCount(value);
-            resultVec[descr->pos - 1] = value;
-        }
-        else {
-
-            Jim_FreeNewObj(interp, value);
-            goto err;
-        }
-    }
-    Jim_DecrRefCount(interp, emptyStr);
-    return resultList;
-  eof:
-    Jim_DecrRefCount(interp, emptyStr);
-    Jim_FreeNewObj(interp, resultList);
-    return (Jim_Obj *)EOF;
-  err:
-    Jim_DecrRefCount(interp, emptyStr);
-    Jim_FreeNewObj(interp, resultList);
-    return 0;
-}
-
-
-static void JimPrngInit(Jim_Interp *interp)
-{
-#define PRNG_SEED_SIZE 256
-    int i;
-    unsigned int *seed;
-    time_t t = time(NULL);
-
-    interp->prngState = Jim_Alloc(sizeof(Jim_PrngState));
-
-    seed = Jim_Alloc(PRNG_SEED_SIZE * sizeof(*seed));
-    for (i = 0; i < PRNG_SEED_SIZE; i++) {
-        seed[i] = (rand() ^ t ^ clock());
-    }
-    JimPrngSeed(interp, (unsigned char *)seed, PRNG_SEED_SIZE * sizeof(*seed));
-    Jim_Free(seed);
-}
-
-
-static void JimRandomBytes(Jim_Interp *interp, void *dest, unsigned int len)
-{
-    Jim_PrngState *prng;
-    unsigned char *destByte = (unsigned char *)dest;
-    unsigned int si, sj, x;
-
-
-    if (interp->prngState == NULL)
-        JimPrngInit(interp);
-    prng = interp->prngState;
-
-    for (x = 0; x < len; x++) {
-        prng->i = (prng->i + 1) & 0xff;
-        si = prng->sbox[prng->i];
-        prng->j = (prng->j + si) & 0xff;
-        sj = prng->sbox[prng->j];
-        prng->sbox[prng->i] = sj;
-        prng->sbox[prng->j] = si;
-        *destByte++ = prng->sbox[(si + sj) & 0xff];
-    }
-}
-
-
-static void JimPrngSeed(Jim_Interp *interp, unsigned char *seed, int seedLen)
-{
-    int i;
-    Jim_PrngState *prng;
-
-
-    if (interp->prngState == NULL)
-        JimPrngInit(interp);
-    prng = interp->prngState;
-
-
-    for (i = 0; i < 256; i++)
-        prng->sbox[i] = i;
-
-    for (i = 0; i < seedLen; i++) {
-        unsigned char t;
-
-        t = prng->sbox[i & 0xFF];
-        prng->sbox[i & 0xFF] = prng->sbox[seed[i]];
-        prng->sbox[seed[i]] = t;
-    }
-    prng->i = prng->j = 0;
-
-    for (i = 0; i < 256; i += seedLen) {
-        JimRandomBytes(interp, seed, seedLen);
-    }
-}
-
-
-static int Jim_IncrCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    jim_wide wideValue, increment = 1;
-    Jim_Obj *intObjPtr;
-
-    if (argc != 2 && argc != 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "varName ?increment?");
-        return JIM_ERR;
-    }
-    if (argc == 3) {
-        if (Jim_GetWideExpr(interp, argv[2], &increment) != JIM_OK)
-            return JIM_ERR;
-    }
-    intObjPtr = Jim_GetVariable(interp, argv[1], JIM_UNSHARED);
-    if (!intObjPtr) {
-
-        wideValue = 0;
-    }
-    else if (Jim_GetWide(interp, intObjPtr, &wideValue) != JIM_OK) {
-        return JIM_ERR;
-    }
-    if (!intObjPtr || Jim_IsShared(intObjPtr)) {
-        intObjPtr = Jim_NewIntObj(interp, wideValue + increment);
-        if (Jim_SetVariable(interp, argv[1], intObjPtr) != JIM_OK) {
-            Jim_FreeNewObj(interp, intObjPtr);
-            return JIM_ERR;
-        }
-    }
-    else {
-
-        Jim_InvalidateStringRep(intObjPtr);
-        JimWideValue(intObjPtr) = wideValue + increment;
-
-        if (argv[1]->typePtr != &variableObjType) {
-
-            Jim_SetVariable(interp, argv[1], intObjPtr);
-        }
-    }
-    Jim_SetResult(interp, intObjPtr);
-    return JIM_OK;
-}
-
-
-#define JIM_EVAL_SARGV_LEN 8
-#define JIM_EVAL_SINTV_LEN 8
-
-static int JimTraceCallback(Jim_Interp *interp, const char *type, int argc, Jim_Obj *const *argv)
-{
-    JimPanic((interp->traceCmdObj == NULL, "xtrace invoked with no object"));
-
-    int ret;
-    Jim_Obj *nargv[7];
-    Jim_Obj *traceCmdObj = interp->traceCmdObj;
-    Jim_Obj *resultObj = Jim_GetResult(interp);
-    ScriptObj *script = NULL;
-
-
-
-    if (interp->evalFrame->scriptObj) {
-        script = JimGetScript(interp, interp->evalFrame->scriptObj);
-    }
-
-    nargv[0] = traceCmdObj;
-    nargv[1] = Jim_NewStringObj(interp, type, -1);
-    nargv[2] = script ? script->fileNameObj : interp->emptyObj;
-    nargv[3] = Jim_NewIntObj(interp, script ? script->linenr : 1);
-    nargv[4] = resultObj;
-    nargv[5] = argv[0];
-    nargv[6] = Jim_NewListObj(interp, argv + 1, argc - 1);
-
-
-    interp->traceCmdObj = NULL;
-
-    Jim_IncrRefCount(resultObj);
-    ret = Jim_EvalObjVector(interp, 7, nargv);
-    Jim_DecrRefCount(interp, resultObj);
-
-    if (ret == JIM_OK || ret == JIM_RETURN) {
-
-        interp->traceCmdObj = traceCmdObj;
-        Jim_SetEmptyResult(interp);
-        ret = JIM_OK;
-    }
-    else {
-
-        Jim_DecrRefCount(interp, traceCmdObj);
-    }
-    return ret;
-}
-
-
-static int JimUnknown(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int retcode;
-
-    if (interp->unknown_called > 50) {
-        return JIM_ERR;
-    }
-
-
-
-    if (Jim_GetCommand(interp, interp->unknown, JIM_NONE) == NULL)
-        return JIM_ERR;
-
-    interp->unknown_called++;
-
-    retcode = Jim_EvalObjPrefix(interp, interp->unknown, argc, argv);
-    interp->unknown_called--;
-
-    return retcode;
-}
-
-static void JimPushEvalFrame(Jim_Interp *interp, Jim_EvalFrame *frame, Jim_Obj *scriptObj)
-{
-    memset(frame, 0, sizeof(*frame));
-    frame->parent = interp->evalFrame;
-    frame->level = frame->parent->level + 1;
-    frame->procLevel = interp->procLevel;
-    frame->framePtr = interp->framePtr;
-    if (scriptObj) {
-        frame->scriptObj = scriptObj;
-    }
-    else {
-        frame->scriptObj = frame->parent->scriptObj;
-    }
-    interp->evalFrame = frame;
-#if 0
-    if (frame->scriptObj) {
-        printf("script: %.*s\n", 20, Jim_String(frame->scriptObj));
-    }
-#endif
-}
-
-static void JimPopEvalFrame(Jim_Interp *interp)
-{
-    interp->evalFrame = interp->evalFrame->parent;
-}
-
-
-static int JimInvokeCommand(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
-{
-    int retcode;
-    Jim_Cmd *cmdPtr;
-    void *prevPrivData;
-    Jim_Obj *tailcallObj = NULL;
-
-#if 0
-    printf("invoke");
-    int j;
-    for (j = 0; j < objc; j++) {
-        printf(" '%s'", Jim_String(objv[j]));
-    }
-    printf("\n");
-#endif
-
-    cmdPtr = Jim_GetCommand(interp, objv[0], JIM_ERRMSG);
-    if (cmdPtr == NULL) {
-        return JimUnknown(interp, objc, objv);
-    }
-    JimIncrCmdRefCount(cmdPtr);
-
-    if (interp->evalDepth == interp->maxEvalDepth) {
-        Jim_SetResultString(interp, "Infinite eval recursion", -1);
-        retcode = JIM_ERR;
-        goto out;
-    }
-    interp->evalDepth++;
-    prevPrivData = interp->cmdPrivData;
-
-tailcall:
-
-    interp->evalFrame->argc = objc;
-    interp->evalFrame->argv = objv;
-    interp->evalFrame->cmd = cmdPtr;
-
-    if (!interp->traceCmdObj ||
-        (retcode = JimTraceCallback(interp, "cmd", objc, objv)) == JIM_OK) {
-
-        Jim_SetEmptyResult(interp);
-        if (cmdPtr->isproc) {
-            retcode = JimCallProcedure(interp, cmdPtr, objc, objv);
-        }
-        else {
-            interp->cmdPrivData = cmdPtr->u.native.privData;
-            retcode = cmdPtr->u.native.cmdProc(interp, objc, objv);
-        }
-        if (retcode == JIM_ERR) {
-            JimSetErrorStack(interp, NULL);
-        }
-    }
-
-    if (tailcallObj) {
-
-        Jim_DecrRefCount(interp, tailcallObj);
-        tailcallObj = NULL;
-    }
-
-
-    interp->evalFrame->argc = 0;
-    interp->evalFrame->argv = NULL;
-
-
-    if (retcode == JIM_EVAL && interp->framePtr->tailcallObj) {
-        JimDecrCmdRefCount(interp, cmdPtr);
-
-
-        cmdPtr = interp->framePtr->tailcallCmd;
-        interp->framePtr->tailcallCmd = NULL;
-        tailcallObj = interp->framePtr->tailcallObj;
-        interp->framePtr->tailcallObj = NULL;
-        objc = tailcallObj->internalRep.listValue.len;
-        objv = tailcallObj->internalRep.listValue.ele;
-        goto tailcall;
-    }
-
-    interp->cmdPrivData = prevPrivData;
-    interp->evalDepth--;
-
-out:
-    JimDecrCmdRefCount(interp, cmdPtr);
-
-    if (retcode == JIM_ERR) {
-        JimSetErrorStack(interp, NULL);
-    }
-
-    if (interp->framePtr->tailcallObj) {
-        JimDecrCmdRefCount(interp, interp->framePtr->tailcallCmd);
-        Jim_DecrRefCount(interp, interp->framePtr->tailcallObj);
-        interp->framePtr->tailcallCmd = NULL;
-        interp->framePtr->tailcallObj = NULL;
-    }
-
-    return retcode;
-}
-
-int Jim_EvalObjVector(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
-{
-    int i, retcode;
-    Jim_EvalFrame frame;
-
-
-    for (i = 0; i < objc; i++)
-        Jim_IncrRefCount(objv[i]);
-
-
-    JimPushEvalFrame(interp, &frame, NULL);
-
-    retcode = JimInvokeCommand(interp, objc, objv);
-
-    JimPopEvalFrame(interp);
-
-
-    for (i = 0; i < objc; i++)
-        Jim_DecrRefCount(interp, objv[i]);
-
-    return retcode;
-}
-
-int Jim_EvalObjPrefix(Jim_Interp *interp, Jim_Obj *prefix, int objc, Jim_Obj *const *objv)
-{
-    int ret;
-    Jim_Obj **nargv = Jim_Alloc((objc + 1) * sizeof(*nargv));
-
-    nargv[0] = prefix;
-    memcpy(&nargv[1], &objv[0], sizeof(nargv[0]) * objc);
-    ret = Jim_EvalObjVector(interp, objc + 1, nargv);
-    Jim_Free(nargv);
-    return ret;
-}
-
-static int JimSubstOneToken(Jim_Interp *interp, const ScriptToken *token, Jim_Obj **objPtrPtr)
-{
-    Jim_Obj *objPtr;
-    int ret = JIM_ERR;
-
-    switch (token->type) {
-        case JIM_TT_STR:
-        case JIM_TT_ESC:
-            objPtr = token->objPtr;
-            break;
-        case JIM_TT_VAR:
-            objPtr = Jim_GetVariable(interp, token->objPtr, JIM_ERRMSG);
-            break;
-        case JIM_TT_DICTSUGAR:
-            objPtr = JimExpandDictSugar(interp, token->objPtr);
-            break;
-        case JIM_TT_EXPRSUGAR:
-            ret = Jim_EvalExpression(interp, token->objPtr);
-            if (ret == JIM_OK) {
-                objPtr = Jim_GetResult(interp);
-            }
-            else {
-                objPtr = NULL;
-            }
-            break;
-        case JIM_TT_CMD:
-            ret = Jim_EvalObj(interp, token->objPtr);
-            if (ret == JIM_OK || ret == JIM_RETURN) {
-                objPtr = interp->result;
-            } else {
-
-                objPtr = NULL;
-            }
-            break;
-        default:
-            JimPanic((1,
-                "default token type (%d) reached " "in Jim_SubstObj().", token->type));
-            objPtr = NULL;
-            break;
-    }
-    if (objPtr) {
-        *objPtrPtr = objPtr;
-        return JIM_OK;
-    }
-    return ret;
-}
-
-static Jim_Obj *JimInterpolateTokens(Jim_Interp *interp, const ScriptToken * token, int tokens, int flags)
-{
-    int totlen = 0, i;
-    Jim_Obj **intv;
-    Jim_Obj *sintv[JIM_EVAL_SINTV_LEN];
-    Jim_Obj *objPtr;
-    char *s;
-
-    if (tokens <= JIM_EVAL_SINTV_LEN)
-        intv = sintv;
-    else
-        intv = Jim_Alloc(sizeof(Jim_Obj *) * tokens);
-
-    for (i = 0; i < tokens; i++) {
-        switch (JimSubstOneToken(interp, &token[i], &intv[i])) {
-            case JIM_OK:
-            case JIM_RETURN:
-                break;
-            case JIM_BREAK:
-                if (flags & JIM_SUBST_FLAG) {
-
-                    tokens = i;
-                    continue;
-                }
-
-
-            case JIM_CONTINUE:
-                if (flags & JIM_SUBST_FLAG) {
-                    intv[i] = NULL;
-                    continue;
-                }
-
-
-            default:
-                while (i--) {
-                    Jim_DecrRefCount(interp, intv[i]);
-                }
-                if (intv != sintv) {
-                    Jim_Free(intv);
-                }
-                return NULL;
-        }
-        Jim_IncrRefCount(intv[i]);
-        Jim_String(intv[i]);
-        totlen += intv[i]->length;
-    }
-
-
-    if (tokens == 1 && intv[0] && intv == sintv) {
-
-        intv[0]->refCount--;
-        return intv[0];
-    }
-
-    objPtr = Jim_NewStringObjNoAlloc(interp, NULL, 0);
-
-    if (tokens == 4 && token[0].type == JIM_TT_ESC && token[1].type == JIM_TT_ESC
-        && token[2].type == JIM_TT_VAR) {
-
-        objPtr->typePtr = &interpolatedObjType;
-        objPtr->internalRep.dictSubstValue.varNameObjPtr = token[0].objPtr;
-        objPtr->internalRep.dictSubstValue.indexObjPtr = intv[2];
-        Jim_IncrRefCount(intv[2]);
-    }
-    else if (tokens && intv[0] && intv[0]->typePtr == &sourceObjType) {
-
-        int line;
-        Jim_Obj *fileNameObj = Jim_GetSourceInfo(interp, intv[0], &line);
-        Jim_SetSourceInfo(interp, objPtr, fileNameObj, line);
-    }
-
-
-    s = objPtr->bytes = Jim_Alloc(totlen + 1);
-    objPtr->length = totlen;
-    for (i = 0; i < tokens; i++) {
-        if (intv[i]) {
-            memcpy(s, intv[i]->bytes, intv[i]->length);
-            s += intv[i]->length;
-            Jim_DecrRefCount(interp, intv[i]);
-        }
-    }
-    objPtr->bytes[totlen] = '\0';
-
-    if (intv != sintv) {
-        Jim_Free(intv);
-    }
-
-    return objPtr;
-}
-
-
-static int JimEvalObjList(Jim_Interp *interp, Jim_Obj *listPtr)
-{
-    int retcode = JIM_OK;
-    Jim_EvalFrame frame;
-
-    JimPanic((Jim_IsList(listPtr) == 0, "JimEvalObjList() invoked on non-list."));
-
-    JimPushEvalFrame(interp, &frame, NULL);
-
-    if (listPtr->internalRep.listValue.len) {
-        Jim_IncrRefCount(listPtr);
-        retcode = JimInvokeCommand(interp,
-            listPtr->internalRep.listValue.len,
-            listPtr->internalRep.listValue.ele);
-        Jim_DecrRefCount(interp, listPtr);
-    }
-
-    JimPopEvalFrame(interp);
-
-    return retcode;
-}
-
-int Jim_EvalObjList(Jim_Interp *interp, Jim_Obj *listPtr)
-{
-    SetListFromAny(interp, listPtr);
-    return JimEvalObjList(interp, listPtr);
-}
-
-int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr)
-{
-    int i;
-    ScriptObj *script;
-    ScriptToken *token;
-    int retcode = JIM_OK;
-    Jim_Obj *sargv[JIM_EVAL_SARGV_LEN], **argv = NULL;
-    Jim_EvalFrame frame;
-
-    if (Jim_IsList(scriptObjPtr) && scriptObjPtr->bytes == NULL) {
-        return JimEvalObjList(interp, scriptObjPtr);
-    }
-
-    Jim_IncrRefCount(scriptObjPtr);
-    script = JimGetScript(interp, scriptObjPtr);
-    if (JimParseCheckMissing(interp, script->missing) == JIM_ERR) {
-        JimSetErrorStack(interp, script);
-        Jim_DecrRefCount(interp, scriptObjPtr);
-        return JIM_ERR;
-    }
-
-    Jim_SetEmptyResult(interp);
-
-    token = script->token;
-
-#ifdef JIM_OPTIMIZATION
-    if (script->len == 0) {
-        Jim_DecrRefCount(interp, scriptObjPtr);
-        return JIM_OK;
-    }
-    if (script->len == 3
-        && token[1].objPtr->typePtr == &commandObjType
-        && token[1].objPtr->internalRep.cmdValue.cmdPtr->isproc == 0
-        && token[1].objPtr->internalRep.cmdValue.cmdPtr->u.native.cmdProc == Jim_IncrCoreCommand
-        && token[2].objPtr->typePtr == &variableObjType) {
-
-        Jim_Obj *objPtr = Jim_GetVariable(interp, token[2].objPtr, JIM_NONE);
-
-        if (objPtr && !Jim_IsShared(objPtr) && objPtr->typePtr == &intObjType) {
-            JimWideValue(objPtr)++;
-            Jim_InvalidateStringRep(objPtr);
-            Jim_DecrRefCount(interp, scriptObjPtr);
-            Jim_SetResult(interp, objPtr);
-            return JIM_OK;
-        }
-    }
-#endif
-
-    script->inUse++;
-
-    JimPushEvalFrame(interp, &frame, scriptObjPtr);
-
-
-    interp->errorFlag = 0;
-    argv = sargv;
-
-    for (i = 0; i < script->len && retcode == JIM_OK; ) {
-        int argc;
-        int j;
-
-
-        argc = token[i].objPtr->internalRep.scriptLineValue.argc;
-        script->linenr = token[i].objPtr->internalRep.scriptLineValue.line;
-
-
-        if (argc > JIM_EVAL_SARGV_LEN)
-            argv = Jim_Alloc(sizeof(Jim_Obj *) * argc);
-
-
-        i++;
-
-        for (j = 0; j < argc; j++) {
-            long wordtokens = 1;
-            int expand = 0;
-            Jim_Obj *wordObjPtr = NULL;
-
-            if (token[i].type == JIM_TT_WORD) {
-                wordtokens = JimWideValue(token[i++].objPtr);
-                if (wordtokens < 0) {
-                    expand = 1;
-                    wordtokens = -wordtokens;
-                }
-            }
-
-            if (wordtokens == 1) {
-
-                switch (token[i].type) {
-                    case JIM_TT_ESC:
-                    case JIM_TT_STR:
-                        wordObjPtr = token[i].objPtr;
-                        break;
-                    case JIM_TT_VAR:
-                        wordObjPtr = Jim_GetVariable(interp, token[i].objPtr, JIM_ERRMSG);
-                        break;
-                    case JIM_TT_EXPRSUGAR:
-                        retcode = Jim_EvalExpression(interp, token[i].objPtr);
-                        if (retcode == JIM_OK) {
-                            wordObjPtr = Jim_GetResult(interp);
-                        }
-                        else {
-                            wordObjPtr = NULL;
-                        }
-                        break;
-                    case JIM_TT_DICTSUGAR:
-                        wordObjPtr = JimExpandDictSugar(interp, token[i].objPtr);
-                        break;
-                    case JIM_TT_CMD:
-                        retcode = Jim_EvalObj(interp, token[i].objPtr);
-                        if (retcode == JIM_OK) {
-                            wordObjPtr = Jim_GetResult(interp);
-                        }
-                        break;
-                    default:
-                        JimPanic((1, "default token type reached " "in Jim_EvalObj()."));
-                }
-            }
-            else {
-                wordObjPtr = JimInterpolateTokens(interp, token + i, wordtokens, JIM_NONE);
-            }
-
-            if (!wordObjPtr) {
-                if (retcode == JIM_OK) {
-                    retcode = JIM_ERR;
-                }
-                break;
-            }
-
-            Jim_IncrRefCount(wordObjPtr);
-            i += wordtokens;
-
-            if (!expand) {
-                argv[j] = wordObjPtr;
-            }
-            else {
-
-                int len = Jim_ListLength(interp, wordObjPtr);
-                int newargc = argc + len - 1;
-                int k;
-
-                if (len > 1) {
-                    if (argv == sargv) {
-                        if (newargc > JIM_EVAL_SARGV_LEN) {
-                            argv = Jim_Alloc(sizeof(*argv) * newargc);
-                            memcpy(argv, sargv, sizeof(*argv) * j);
-                        }
-                    }
-                    else {
-
-                        argv = Jim_Realloc(argv, sizeof(*argv) * newargc);
-                    }
-                }
-
-
-                for (k = 0; k < len; k++) {
-                    argv[j++] = wordObjPtr->internalRep.listValue.ele[k];
-                    Jim_IncrRefCount(wordObjPtr->internalRep.listValue.ele[k]);
-                }
-
-                Jim_DecrRefCount(interp, wordObjPtr);
-
-
-                j--;
-                argc += len - 1;
-            }
-        }
-
-        if (retcode == JIM_OK && argc) {
-
-            retcode = JimInvokeCommand(interp, argc, argv);
-
-            if (Jim_CheckSignal(interp)) {
-                retcode = JIM_SIGNAL;
-            }
-        }
-
-
-        while (j-- > 0) {
-            Jim_DecrRefCount(interp, argv[j]);
-        }
-
-        if (argv != sargv) {
-            Jim_Free(argv);
-            argv = sargv;
-        }
-    }
-
-
-    if (retcode == JIM_ERR) {
-        JimSetErrorStack(interp, NULL);
-    }
-
-    JimPopEvalFrame(interp);
-
-    Jim_FreeIntRep(interp, scriptObjPtr);
-    scriptObjPtr->typePtr = &scriptObjType;
-    Jim_SetIntRepPtr(scriptObjPtr, script);
-    Jim_DecrRefCount(interp, scriptObjPtr);
-
-    return retcode;
-}
-
-static int JimSetProcArg(Jim_Interp *interp, Jim_Obj *argNameObj, Jim_Obj *argValObj)
-{
-    int retcode;
-
-    const char *varname = Jim_String(argNameObj);
-    if (*varname == '&') {
-
-        Jim_Obj *objPtr;
-        Jim_CallFrame *savedCallFrame = interp->framePtr;
-
-        interp->framePtr = interp->framePtr->parent;
-        objPtr = Jim_GetVariable(interp, argValObj, JIM_ERRMSG);
-        interp->framePtr = savedCallFrame;
-        if (!objPtr) {
-            return JIM_ERR;
-        }
-
-
-        objPtr = Jim_NewStringObj(interp, varname + 1, -1);
-        Jim_IncrRefCount(objPtr);
-        retcode = Jim_SetVariableLink(interp, objPtr, argValObj, interp->framePtr->parent);
-        Jim_DecrRefCount(interp, objPtr);
-    }
-    else {
-        retcode = Jim_SetVariable(interp, argNameObj, argValObj);
-    }
-    return retcode;
-}
-
-static void JimSetProcWrongArgs(Jim_Interp *interp, Jim_Obj *procNameObj, Jim_Cmd *cmd)
-{
-
-    Jim_Obj *argmsg = Jim_NewStringObj(interp, "", 0);
-    int i;
-
-    for (i = 0; i < cmd->u.proc.argListLen; i++) {
-        Jim_AppendString(interp, argmsg, " ", 1);
-
-        if (i == cmd->u.proc.argsPos) {
-            if (cmd->u.proc.arglist[i].defaultObjPtr) {
-
-                Jim_AppendString(interp, argmsg, "?", 1);
-                Jim_AppendObj(interp, argmsg, cmd->u.proc.arglist[i].defaultObjPtr);
-                Jim_AppendString(interp, argmsg, " ...?", -1);
-            }
-            else {
-
-                Jim_AppendString(interp, argmsg, "?arg ...?", -1);
-            }
-        }
-        else {
-            if (cmd->u.proc.arglist[i].defaultObjPtr) {
-                Jim_AppendString(interp, argmsg, "?", 1);
-                Jim_AppendObj(interp, argmsg, cmd->u.proc.arglist[i].nameObjPtr);
-                Jim_AppendString(interp, argmsg, "?", 1);
-            }
-            else {
-                const char *arg = Jim_String(cmd->u.proc.arglist[i].nameObjPtr);
-                if (*arg == '&') {
-                    arg++;
-                }
-                Jim_AppendString(interp, argmsg, arg, -1);
-            }
-        }
-    }
-    Jim_SetResultFormatted(interp, "wrong # args: should be \"%#s%#s\"", procNameObj, argmsg);
-}
-
-#ifdef jim_ext_namespace
-int Jim_EvalNamespace(Jim_Interp *interp, Jim_Obj *scriptObj, Jim_Obj *nsObj)
-{
-    Jim_CallFrame *callFramePtr;
-    int retcode;
-
-
-    callFramePtr = JimCreateCallFrame(interp, interp->framePtr, nsObj);
-    callFramePtr->argv = interp->evalFrame->argv;
-    callFramePtr->argc = interp->evalFrame->argc;
-    callFramePtr->procArgsObjPtr = NULL;
-    callFramePtr->procBodyObjPtr = scriptObj;
-    callFramePtr->staticVars = NULL;
-    Jim_IncrRefCount(scriptObj);
-    interp->framePtr = callFramePtr;
-
-
-    if (interp->framePtr->level == interp->maxCallFrameDepth) {
-        Jim_SetResultString(interp, "Too many nested calls. Infinite recursion?", -1);
-        retcode = JIM_ERR;
-    }
-    else {
-
-        retcode = Jim_EvalObj(interp, scriptObj);
-    }
-
-
-    interp->framePtr = interp->framePtr->parent;
-    JimFreeCallFrame(interp, callFramePtr, JIM_FCF_REUSE);
-
-    return retcode;
-}
-#endif
-
-static int JimCallProcedure(Jim_Interp *interp, Jim_Cmd *cmd, int argc, Jim_Obj *const *argv)
-{
-    Jim_CallFrame *callFramePtr;
-    int i, d, retcode, optargs;
-
-
-    if (argc - 1 < cmd->u.proc.reqArity ||
-        (cmd->u.proc.argsPos < 0 && argc - 1 > cmd->u.proc.reqArity + cmd->u.proc.optArity)) {
-        JimSetProcWrongArgs(interp, argv[0], cmd);
-        return JIM_ERR;
-    }
-
-    if (Jim_Length(cmd->u.proc.bodyObjPtr) == 0) {
-
-        return JIM_OK;
-    }
-
-
-    if (interp->framePtr->level == interp->maxCallFrameDepth) {
-        Jim_SetResultString(interp, "Too many nested calls. Infinite recursion?", -1);
-        return JIM_ERR;
-    }
-
-
-    callFramePtr = JimCreateCallFrame(interp, interp->framePtr, cmd->u.proc.nsObj);
-    callFramePtr->argv = argv;
-    callFramePtr->argc = argc;
-    callFramePtr->procArgsObjPtr = cmd->u.proc.argListObjPtr;
-    callFramePtr->procBodyObjPtr = cmd->u.proc.bodyObjPtr;
-    callFramePtr->staticVars = cmd->u.proc.staticVars;
-
-    interp->procLevel++;
-
-    Jim_IncrRefCount(cmd->u.proc.argListObjPtr);
-    Jim_IncrRefCount(cmd->u.proc.bodyObjPtr);
-    interp->framePtr = callFramePtr;
-
-
-    optargs = (argc - 1 - cmd->u.proc.reqArity);
-
-
-    i = 1;
-    for (d = 0; d < cmd->u.proc.argListLen; d++) {
-        Jim_Obj *nameObjPtr = cmd->u.proc.arglist[d].nameObjPtr;
-        if (d == cmd->u.proc.argsPos) {
-
-            Jim_Obj *listObjPtr;
-            int argsLen = 0;
-            if (cmd->u.proc.reqArity + cmd->u.proc.optArity < argc - 1) {
-                argsLen = argc - 1 - (cmd->u.proc.reqArity + cmd->u.proc.optArity);
-            }
-            listObjPtr = Jim_NewListObj(interp, &argv[i], argsLen);
-
-
-            if (cmd->u.proc.arglist[d].defaultObjPtr) {
-                nameObjPtr =cmd->u.proc.arglist[d].defaultObjPtr;
-            }
-            retcode = Jim_SetVariable(interp, nameObjPtr, listObjPtr);
-            if (retcode != JIM_OK) {
-                goto badargset;
-            }
-
-            i += argsLen;
-            continue;
-        }
-
-
-        if (cmd->u.proc.arglist[d].defaultObjPtr == NULL || optargs-- > 0) {
-            retcode = JimSetProcArg(interp, nameObjPtr, argv[i++]);
-        }
-        else {
-
-            retcode = Jim_SetVariable(interp, nameObjPtr, cmd->u.proc.arglist[d].defaultObjPtr);
-        }
-        if (retcode != JIM_OK) {
-            goto badargset;
-        }
-    }
-
-    if (interp->traceCmdObj == NULL ||
-        (retcode = JimTraceCallback(interp, "proc", argc, argv)) == JIM_OK) {
-
-        retcode = Jim_EvalObj(interp, cmd->u.proc.bodyObjPtr);
-    }
-
-badargset:
-
-
-    retcode = JimInvokeDefer(interp, retcode);
-    interp->framePtr = interp->framePtr->parent;
-    JimFreeCallFrame(interp, callFramePtr, JIM_FCF_REUSE);
-
-
-    if (retcode == JIM_RETURN) {
-        if (--interp->returnLevel <= 0) {
-            retcode = interp->returnCode;
-            interp->returnCode = JIM_OK;
-            interp->returnLevel = 0;
-        }
-    }
-    interp->procLevel--;
-
-    return retcode;
-}
-
-int Jim_EvalSource(Jim_Interp *interp, const char *filename, int lineno, const char *script)
-{
-    int retval;
-    Jim_Obj *scriptObjPtr;
-
-    scriptObjPtr = Jim_NewStringObj(interp, script, -1);
-    Jim_IncrRefCount(scriptObjPtr);
-    if (filename) {
-        Jim_SetSourceInfo(interp, scriptObjPtr, Jim_NewStringObj(interp, filename, -1), lineno);
-    }
-    retval = Jim_EvalObj(interp, scriptObjPtr);
-    Jim_DecrRefCount(interp, scriptObjPtr);
-    return retval;
-}
-
-int Jim_Eval(Jim_Interp *interp, const char *script)
-{
-    return Jim_EvalObj(interp, Jim_NewStringObj(interp, script, -1));
-}
-
-
-int Jim_EvalGlobal(Jim_Interp *interp, const char *script)
-{
-    int retval;
-    Jim_CallFrame *savedFramePtr = interp->framePtr;
-
-    interp->framePtr = interp->topFramePtr;
-    retval = Jim_Eval(interp, script);
-    interp->framePtr = savedFramePtr;
-
-    return retval;
-}
-
-int Jim_EvalFileGlobal(Jim_Interp *interp, const char *filename)
-{
-    int retval;
-    Jim_CallFrame *savedFramePtr = interp->framePtr;
-
-    interp->framePtr = interp->topFramePtr;
-    retval = Jim_EvalFile(interp, filename);
-    interp->framePtr = savedFramePtr;
-
-    return retval;
-}
-
-#include <sys/stat.h>
-
-static Jim_Obj *JimReadTextFile(Jim_Interp *interp, const char *filename)
-{
-    jim_stat_t sb;
-    int fd;
-    char *buf;
-    int readlen;
-
-    if (Jim_Stat(filename, &sb) == -1 || (fd = open(filename, O_RDONLY | O_TEXT, 0666)) < 0) {
-        Jim_SetResultFormatted(interp, "couldn't read file \"%s\": %s", filename, strerror(errno));
-        return NULL;
-    }
-    buf = Jim_Alloc(sb.st_size + 1);
-    readlen = read(fd, buf, sb.st_size);
-    close(fd);
-    if (readlen < 0) {
-        Jim_Free(buf);
-        Jim_SetResultFormatted(interp, "failed to load file \"%s\": %s", filename, strerror(errno));
-        return NULL;
-    }
-    else {
-        Jim_Obj *objPtr;
-        buf[readlen] = 0;
-
-        objPtr = Jim_NewStringObjNoAlloc(interp, buf, readlen);
-
-        return objPtr;
-    }
-}
-
-
-int Jim_EvalFile(Jim_Interp *interp, const char *filename)
-{
-    Jim_Obj *filenameObj;
-    Jim_Obj *oldFilenameObj;
-    Jim_Obj *scriptObjPtr;
-    int retcode;
-
-    scriptObjPtr = JimReadTextFile(interp, filename);
-    if (!scriptObjPtr) {
-        return JIM_ERR;
-    }
-
-    filenameObj = Jim_NewStringObj(interp, filename, -1);
-    Jim_SetSourceInfo(interp, scriptObjPtr, filenameObj, 1);
-
-    oldFilenameObj = JimPushInterpObj(interp->currentFilenameObj, filenameObj);
-
-    retcode = Jim_EvalObj(interp, scriptObjPtr);
-
-    JimPopInterpObj(interp, interp->currentFilenameObj, oldFilenameObj);
-
-
-    if (retcode == JIM_RETURN) {
-        if (--interp->returnLevel <= 0) {
-            retcode = interp->returnCode;
-            interp->returnCode = JIM_OK;
-            interp->returnLevel = 0;
-        }
-    }
-
-    return retcode;
-}
-
-static void JimParseSubst(struct JimParserCtx *pc, int flags)
-{
-    pc->tstart = pc->p;
-    pc->tline = pc->linenr;
-
-    if (pc->len == 0) {
-        pc->tend = pc->p;
-        pc->tt = JIM_TT_EOL;
-        pc->eof = 1;
-        return;
-    }
-    if (*pc->p == '[' && !(flags & JIM_SUBST_NOCMD)) {
-        JimParseCmd(pc);
-        return;
-    }
-    if (*pc->p == '$' && !(flags & JIM_SUBST_NOVAR)) {
-        if (JimParseVar(pc) == JIM_OK) {
-            return;
-        }
-
-        pc->tstart = pc->p;
-
-        pc->p++;
-        pc->len--;
-    }
-    while (pc->len) {
-        if (*pc->p == '$' && !(flags & JIM_SUBST_NOVAR)) {
-            break;
-        }
-        if (*pc->p == '[' && !(flags & JIM_SUBST_NOCMD)) {
-            break;
-        }
-        if (*pc->p == '\\' && pc->len > 1) {
-            pc->p++;
-            pc->len--;
-        }
-        pc->p++;
-        pc->len--;
-    }
-    pc->tend = pc->p - 1;
-    pc->tt = (flags & JIM_SUBST_NOESC) ? JIM_TT_STR : JIM_TT_ESC;
-}
-
-
-static int SetSubstFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr, int flags)
-{
-    int scriptTextLen;
-    const char *scriptText = Jim_GetString(objPtr, &scriptTextLen);
-    struct JimParserCtx parser;
-    struct ScriptObj *script = Jim_Alloc(sizeof(*script));
-    ParseTokenList tokenlist;
-
-
-    ScriptTokenListInit(&tokenlist);
-
-    JimParserInit(&parser, scriptText, scriptTextLen, 1);
-    while (1) {
-        JimParseSubst(&parser, flags);
-        if (parser.eof) {
-
-            break;
-        }
-        ScriptAddToken(&tokenlist, parser.tstart, parser.tend - parser.tstart + 1, parser.tt,
-            parser.tline);
-    }
-
-
-    script->inUse = 1;
-    script->substFlags = flags;
-    script->fileNameObj = interp->emptyObj;
-    Jim_IncrRefCount(script->fileNameObj);
-    SubstObjAddTokens(interp, script, &tokenlist);
-
-
-    ScriptTokenListFree(&tokenlist);
-
-#ifdef DEBUG_SHOW_SUBST
-    {
-        int i;
-
-        printf("==== Subst ====\n");
-        for (i = 0; i < script->len; i++) {
-            printf("[%2d] %s '%s'\n", i, jim_tt_name(script->token[i].type),
-                Jim_String(script->token[i].objPtr));
-        }
-    }
-#endif
-
-
-    Jim_FreeIntRep(interp, objPtr);
-    Jim_SetIntRepPtr(objPtr, script);
-    objPtr->typePtr = &scriptObjType;
-    return JIM_OK;
-}
-
-static ScriptObj *Jim_GetSubst(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
-{
-    if (objPtr->typePtr != &scriptObjType || ((ScriptObj *)Jim_GetIntRepPtr(objPtr))->substFlags != flags)
-        SetSubstFromAny(interp, objPtr, flags);
-    return (ScriptObj *) Jim_GetIntRepPtr(objPtr);
-}
-
-int Jim_SubstObj(Jim_Interp *interp, Jim_Obj *substObjPtr, Jim_Obj **resObjPtrPtr, int flags)
-{
-    ScriptObj *script;
-
-    JimPanic((substObjPtr->refCount == 0, "Jim_SubstObj() called with zero refcount object"));
-
-    script = Jim_GetSubst(interp, substObjPtr, flags);
-
-    Jim_IncrRefCount(substObjPtr);
-    script->inUse++;
-
-    *resObjPtrPtr = JimInterpolateTokens(interp, script->token, script->len, flags);
-
-    script->inUse--;
-    Jim_DecrRefCount(interp, substObjPtr);
-    if (*resObjPtrPtr == NULL) {
-        return JIM_ERR;
-    }
-    return JIM_OK;
-}
-
-void Jim_WrongNumArgs(Jim_Interp *interp, int argc, Jim_Obj *const *argv, const char *msg)
-{
-    Jim_Obj *objPtr;
-    Jim_Obj *listObjPtr;
-
-    JimPanic((argc == 0, "Jim_WrongNumArgs() called with argc=0"));
-
-    listObjPtr = Jim_NewListObj(interp, argv, argc);
-
-    if (msg && *msg) {
-        Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp, msg, -1));
-    }
-    Jim_IncrRefCount(listObjPtr);
-    objPtr = Jim_ListJoin(interp, listObjPtr, " ", 1);
-    Jim_DecrRefCount(interp, listObjPtr);
-
-    Jim_SetResultFormatted(interp, "wrong # args: should be \"%#s\"", objPtr);
-}
-
-typedef void JimHashtableIteratorCallbackType(Jim_Interp *interp, Jim_Obj *listObjPtr,
-    Jim_Obj *keyObjPtr, void *value, Jim_Obj *patternObjPtr, int type);
-
-#define JimTrivialMatch(pattern)    (strpbrk((pattern), "*[?\\") == NULL)
-
-static Jim_Obj *JimHashtablePatternMatch(Jim_Interp *interp, Jim_HashTable *ht, Jim_Obj *patternObjPtr,
-    JimHashtableIteratorCallbackType *callback, int type)
-{
-    Jim_HashEntry *he;
-    Jim_Obj *listObjPtr = Jim_NewListObj(interp, NULL, 0);
-
-
-    if (patternObjPtr && JimTrivialMatch(Jim_String(patternObjPtr))) {
-        he = Jim_FindHashEntry(ht, patternObjPtr);
-        if (he) {
-            callback(interp, listObjPtr, Jim_GetHashEntryKey(he), Jim_GetHashEntryVal(he),
-                patternObjPtr, type);
-        }
-    }
-    else {
-        Jim_HashTableIterator htiter;
-        JimInitHashTableIterator(ht, &htiter);
-        while ((he = Jim_NextHashEntry(&htiter)) != NULL) {
-            callback(interp, listObjPtr, Jim_GetHashEntryKey(he), Jim_GetHashEntryVal(he),
-                patternObjPtr, type);
-        }
-    }
-    return listObjPtr;
-}
-
-
-#define JIM_CMDLIST_COMMANDS 0
-#define JIM_CMDLIST_PROCS 1
-#define JIM_CMDLIST_CHANNELS 2
-
-static void JimCommandMatch(Jim_Interp *interp, Jim_Obj *listObjPtr,
-    Jim_Obj *keyObj, void *value, Jim_Obj *patternObj, int type)
-{
-    Jim_Cmd *cmdPtr = (Jim_Cmd *)value;
-
-    if (type == JIM_CMDLIST_PROCS && !cmdPtr->isproc) {
-
-        return;
-    }
-
-    Jim_IncrRefCount(keyObj);
-
-    if (type != JIM_CMDLIST_CHANNELS || Jim_AioFilehandle(interp, keyObj) >= 0) {
-        int match = 1;
-        if (patternObj) {
-            int plen, slen;
-            const char *pattern = Jim_GetStringNoQualifier(patternObj, &plen);
-            const char *str = Jim_GetStringNoQualifier(keyObj, &slen);
-#ifdef JIM_NO_INTROSPECTION
-
-            match = (JimStringCompareUtf8(pattern, plen, str, slen, 0) == 0);
-#else
-            match = JimGlobMatch(pattern, plen, str, slen, 0);
-#endif
-        }
-        if (match) {
-            Jim_ListAppendElement(interp, listObjPtr, keyObj);
-        }
-    }
-    Jim_DecrRefCount(interp, keyObj);
-}
-
-static Jim_Obj *JimCommandsList(Jim_Interp *interp, Jim_Obj *patternObjPtr, int type)
-{
-    return JimHashtablePatternMatch(interp, &interp->commands, patternObjPtr, JimCommandMatch, type);
-}
-
-
-#define JIM_VARLIST_GLOBALS 0
-#define JIM_VARLIST_LOCALS 1
-#define JIM_VARLIST_VARS 2
-#define JIM_VARLIST_MASK 0x000f
-
-#define JIM_VARLIST_VALUES 0x1000
-
-static void JimVariablesMatch(Jim_Interp *interp, Jim_Obj *listObjPtr,
-    Jim_Obj *keyObj, void *value, Jim_Obj *patternObj, int type)
-{
-    Jim_VarVal *vv = (Jim_VarVal *)value;
-
-    if ((type & JIM_VARLIST_MASK) != JIM_VARLIST_LOCALS || vv->linkFramePtr == NULL) {
-        if (patternObj == NULL || Jim_StringMatchObj(interp, patternObj, keyObj, 0)) {
-            Jim_ListAppendElement(interp, listObjPtr, keyObj);
-            if (type & JIM_VARLIST_VALUES) {
-                Jim_ListAppendElement(interp, listObjPtr, vv->objPtr);
-            }
-        }
-    }
-}
-
-
-static Jim_Obj *JimVariablesList(Jim_Interp *interp, Jim_Obj *patternObjPtr, int mode)
-{
-    if (mode == JIM_VARLIST_LOCALS && interp->framePtr == interp->topFramePtr) {
-        return interp->emptyObj;
-    }
-    else {
-        Jim_CallFrame *framePtr = (mode == JIM_VARLIST_GLOBALS) ? interp->topFramePtr : interp->framePtr;
-        return JimHashtablePatternMatch(interp, &framePtr->vars, patternObjPtr, JimVariablesMatch,
-            mode);
-    }
-}
-
-static int JimInfoLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr, Jim_Obj **objPtrPtr)
-{
-    long level;
-
-    if (Jim_GetLong(interp, levelObjPtr, &level) == JIM_OK) {
-        Jim_CallFrame *targetCallFrame = JimGetCallFrameByInteger(interp, level);
-        if (targetCallFrame && targetCallFrame != interp->topFramePtr) {
-#ifdef JIM_NO_INTROSPECTION
-
-            *objPtrPtr = Jim_NewListObj(interp, targetCallFrame->argv, 1);
-#else
-            *objPtrPtr = Jim_NewListObj(interp, targetCallFrame->argv, targetCallFrame->argc);
-#endif
-            return JIM_OK;
-        }
-    }
-    Jim_SetResultFormatted(interp, "bad level \"%#s\"", levelObjPtr);
-    return JIM_ERR;
-}
-
-static int JimInfoFrame(Jim_Interp *interp, Jim_Obj *levelObjPtr, Jim_Obj **objPtrPtr)
-{
-    long level;
-
-    if (Jim_GetLong(interp, levelObjPtr, &level) == JIM_OK) {
-        Jim_EvalFrame *frame = JimGetEvalFrameByProcLevel(interp, level);
-        if (frame) {
-            Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
-
-            Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, "type", -1));
-            Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, "source", -1));
-            if (frame->scriptObj) {
-                ScriptObj *script = JimGetScript(interp, frame->scriptObj);
-                Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, "line", -1));
-                Jim_ListAppendElement(interp, listObj, Jim_NewIntObj(interp, script->linenr));
-                Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, "file", -1));
-                Jim_ListAppendElement(interp, listObj, script->fileNameObj);
-            }
-#ifndef JIM_NO_INTROSPECTION
-            {
-                Jim_Obj *cmdObj = Jim_NewListObj(interp, frame->argv, frame->argc);
-
-                Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, "cmd", -1));
-                Jim_ListAppendElement(interp, listObj, cmdObj);
-            }
-#endif
-            {
-                Jim_Obj *procNameObj = JimProcForEvalFrame(interp, frame);
-                if (procNameObj) {
-                    Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, "proc", -1));
-                    Jim_ListAppendElement(interp, listObj, procNameObj);
-                 }
-            }
-            Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, "level", -1));
-            Jim_ListAppendElement(interp, listObj, Jim_NewIntObj(interp, interp->framePtr->level - frame->framePtr->level));
-
-            *objPtrPtr = listObj;
-            return JIM_OK;
-        }
-    }
-    Jim_SetResultFormatted(interp, "bad level \"%#s\"", levelObjPtr);
-    return JIM_ERR;
-}
-
-
-static int Jim_PutsCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    if (argc != 2 && argc != 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "?-nonewline? string");
-        return JIM_ERR;
-    }
-    if (argc == 3) {
-        if (!Jim_CompareStringImmediate(interp, argv[1], "-nonewline")) {
-            Jim_SetResultString(interp, "The second argument must " "be -nonewline", -1);
-            return JIM_ERR;
-        }
-        else {
-            fputs(Jim_String(argv[2]), stdout);
-        }
-    }
-    else {
-        puts(Jim_String(argv[1]));
-    }
-    return JIM_OK;
-}
-
-
-static int JimAddMulHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int op)
-{
-    jim_wide wideValue, res;
-    double doubleValue, doubleRes;
-    int i;
-
-    res = (op == JIM_EXPROP_ADD) ? 0 : 1;
-
-    for (i = 1; i < argc; i++) {
-        if (Jim_GetWide(interp, argv[i], &wideValue) != JIM_OK)
-            goto trydouble;
-        if (op == JIM_EXPROP_ADD)
-            res += wideValue;
-        else
-            res *= wideValue;
-    }
-    Jim_SetResultInt(interp, res);
-    return JIM_OK;
-  trydouble:
-    doubleRes = (double)res;
-    for (; i < argc; i++) {
-        if (Jim_GetDouble(interp, argv[i], &doubleValue) != JIM_OK)
-            return JIM_ERR;
-        if (op == JIM_EXPROP_ADD)
-            doubleRes += doubleValue;
-        else
-            doubleRes *= doubleValue;
-    }
-    Jim_SetResult(interp, Jim_NewDoubleObj(interp, doubleRes));
-    return JIM_OK;
-}
-
-
-static int JimSubDivHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int op)
-{
-    jim_wide wideValue, res = 0;
-    double doubleValue, doubleRes = 0;
-    int i = 2;
-
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "number ?number ... number?");
-        return JIM_ERR;
-    }
-    else if (argc == 2) {
-        if (Jim_GetWide(interp, argv[1], &wideValue) != JIM_OK) {
-            if (Jim_GetDouble(interp, argv[1], &doubleValue) != JIM_OK) {
-                return JIM_ERR;
-            }
-            else {
-                if (op == JIM_EXPROP_SUB)
-                    doubleRes = -doubleValue;
-                else
-                    doubleRes = 1.0 / doubleValue;
-                Jim_SetResult(interp, Jim_NewDoubleObj(interp, doubleRes));
-                return JIM_OK;
-            }
-        }
-        if (op == JIM_EXPROP_SUB) {
-            res = -wideValue;
-            Jim_SetResultInt(interp, res);
-        }
-        else {
-            doubleRes = 1.0 / wideValue;
-            Jim_SetResult(interp, Jim_NewDoubleObj(interp, doubleRes));
-        }
-        return JIM_OK;
-    }
-    else {
-        if (Jim_GetWide(interp, argv[1], &res) != JIM_OK) {
-            if (Jim_GetDouble(interp, argv[1], &doubleRes)
-                != JIM_OK) {
-                return JIM_ERR;
-            }
-            else {
-                goto trydouble;
-            }
-        }
-    }
-    for (i = 2; i < argc; i++) {
-        if (Jim_GetWide(interp, argv[i], &wideValue) != JIM_OK) {
-            doubleRes = (double)res;
-            goto trydouble;
-        }
-        if (op == JIM_EXPROP_SUB)
-            res -= wideValue;
-        else {
-            if (wideValue == 0) {
-                Jim_SetResultString(interp, "Division by zero", -1);
-                return JIM_ERR;
-            }
-            res /= wideValue;
-        }
-    }
-    Jim_SetResultInt(interp, res);
-    return JIM_OK;
-  trydouble:
-    for (; i < argc; i++) {
-        if (Jim_GetDouble(interp, argv[i], &doubleValue) != JIM_OK)
-            return JIM_ERR;
-        if (op == JIM_EXPROP_SUB)
-            doubleRes -= doubleValue;
-        else
-            doubleRes /= doubleValue;
-    }
-    Jim_SetResult(interp, Jim_NewDoubleObj(interp, doubleRes));
-    return JIM_OK;
-}
-
-
-
-static int Jim_AddCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return JimAddMulHelper(interp, argc, argv, JIM_EXPROP_ADD);
-}
-
-
-static int Jim_MulCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return JimAddMulHelper(interp, argc, argv, JIM_EXPROP_MUL);
-}
-
-
-static int Jim_SubCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return JimSubDivHelper(interp, argc, argv, JIM_EXPROP_SUB);
-}
-
-
-static int Jim_DivCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return JimSubDivHelper(interp, argc, argv, JIM_EXPROP_DIV);
-}
-
-
-static int Jim_SetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    if (argc != 2 && argc != 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "varName ?newValue?");
-        return JIM_ERR;
-    }
-    if (argc == 2) {
-        Jim_Obj *objPtr;
-
-        objPtr = Jim_GetVariable(interp, argv[1], JIM_ERRMSG);
-        if (!objPtr)
-            return JIM_ERR;
-        Jim_SetResult(interp, objPtr);
-        return JIM_OK;
-    }
-
-    if (Jim_SetVariable(interp, argv[1], argv[2]) != JIM_OK)
-        return JIM_ERR;
-    Jim_SetResult(interp, argv[2]);
-    return JIM_OK;
-}
-
-static int Jim_UnsetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int i = 1;
-    int complain = 1;
-
-    while (i < argc) {
-        if (Jim_CompareStringImmediate(interp, argv[i], "--")) {
-            i++;
-            break;
-        }
-        if (Jim_CompareStringImmediate(interp, argv[i], "-nocomplain")) {
-            complain = 0;
-            i++;
-            continue;
-        }
-        break;
-    }
-
-    while (i < argc) {
-        if (Jim_UnsetVariable(interp, argv[i], complain ? JIM_ERRMSG : JIM_NONE) != JIM_OK
-            && complain) {
-            return JIM_ERR;
-        }
-        i++;
-    }
-
-    Jim_SetEmptyResult(interp);
-    return JIM_OK;
-}
-
-static int JimCheckLoopRetcode(Jim_Interp *interp, int retval)
-{
-    if (retval == JIM_BREAK || retval == JIM_CONTINUE) {
-        if (--interp->break_level > 0) {
-            return 1;
-        }
-    }
-    return 0;
-}
-
-
-static int Jim_WhileCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    if (argc != 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "condition body");
-        return JIM_ERR;
-    }
-
-
-    while (1) {
-        int boolean = 0, retval;
-
-        if ((retval = Jim_GetBoolFromExpr(interp, argv[1], &boolean)) != JIM_OK)
-            return retval;
-        if (!boolean)
-            break;
-
-        if ((retval = Jim_EvalObj(interp, argv[2])) != JIM_OK) {
-            if (JimCheckLoopRetcode(interp, retval)) {
-                return retval;
-            }
-            switch (retval) {
-                case JIM_BREAK:
-                    goto out;
-                case JIM_CONTINUE:
-                    continue;
-                default:
-                    return retval;
-            }
-        }
-    }
-  out:
-    Jim_SetEmptyResult(interp);
-    return JIM_OK;
-}
-
-
-static int Jim_ForCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int retval;
-    int boolean = 1;
-    int immediate = 0;
-    Jim_Obj *varNamePtr = NULL;
-    Jim_Obj *stopVarNamePtr = NULL;
-
-    if (argc != 5) {
-        Jim_WrongNumArgs(interp, 1, argv, "start test next body");
-        return JIM_ERR;
-    }
-
-
-    if ((retval = Jim_EvalObj(interp, argv[1])) != JIM_OK) {
-        return retval;
-    }
-
-    retval = Jim_GetBoolFromExpr(interp, argv[2], &boolean);
-
-
-#ifdef JIM_OPTIMIZATION
-    if (retval == JIM_OK && boolean) {
-        ScriptObj *incrScript;
-        struct ExprTree *expr;
-        jim_wide stop, currentVal;
-        Jim_Obj *objPtr;
-        int cmpOffset;
-
-
-        expr = JimGetExpression(interp, argv[2]);
-        incrScript = JimGetScript(interp, argv[3]);
-
-
-        if (incrScript == NULL || incrScript->len != 3 || !expr || expr->len != 3) {
-            goto evalstart;
-        }
-
-        if (incrScript->token[1].type != JIM_TT_ESC) {
-            goto evalstart;
-        }
-
-        if (expr->expr->type == JIM_EXPROP_LT) {
-            cmpOffset = 0;
-        }
-        else if (expr->expr->type == JIM_EXPROP_LTE) {
-            cmpOffset = 1;
-        }
-        else {
-            goto evalstart;
-        }
-
-        if (expr->expr->left->type != JIM_TT_VAR) {
-            goto evalstart;
-        }
-
-        if (expr->expr->right->type != JIM_TT_VAR && expr->expr->right->type != JIM_TT_EXPR_INT) {
-            goto evalstart;
-        }
-
-
-        if (!Jim_CompareStringImmediate(interp, incrScript->token[1].objPtr, "incr")) {
-            goto evalstart;
-        }
-
-
-        if (!Jim_StringEqObj(incrScript->token[2].objPtr, expr->expr->left->objPtr)) {
-            goto evalstart;
-        }
-
-
-        if (expr->expr->right->type == JIM_TT_EXPR_INT) {
-            if (Jim_GetWideExpr(interp, expr->expr->right->objPtr, &stop) == JIM_ERR) {
-                goto evalstart;
-            }
-        }
-        else {
-            stopVarNamePtr = expr->expr->right->objPtr;
-            Jim_IncrRefCount(stopVarNamePtr);
-
-            stop = 0;
-        }
-
-
-        varNamePtr = expr->expr->left->objPtr;
-        Jim_IncrRefCount(varNamePtr);
-
-        objPtr = Jim_GetVariable(interp, varNamePtr, JIM_NONE);
-        if (objPtr == NULL || Jim_GetWide(interp, objPtr, &currentVal) != JIM_OK) {
-            goto testcond;
-        }
-
-
-        while (retval == JIM_OK) {
-
-
-
-
-            if (stopVarNamePtr) {
-                objPtr = Jim_GetVariable(interp, stopVarNamePtr, JIM_NONE);
-                if (objPtr == NULL || Jim_GetWide(interp, objPtr, &stop) != JIM_OK) {
-                    goto testcond;
-                }
-            }
-
-            if (currentVal >= stop + cmpOffset) {
-                break;
-            }
-
-
-            retval = Jim_EvalObj(interp, argv[4]);
-            if (JimCheckLoopRetcode(interp, retval)) {
-                immediate++;
-                goto out;
-            }
-            if (retval == JIM_OK || retval == JIM_CONTINUE) {
-                retval = JIM_OK;
-
-                objPtr = Jim_GetVariable(interp, varNamePtr, JIM_ERRMSG);
-
-
-                if (objPtr == NULL) {
-                    retval = JIM_ERR;
-                    goto out;
-                }
-                if (!Jim_IsShared(objPtr) && objPtr->typePtr == &intObjType) {
-                    currentVal = ++JimWideValue(objPtr);
-                    Jim_InvalidateStringRep(objPtr);
-                }
-                else {
-                    if (Jim_GetWide(interp, objPtr, &currentVal) != JIM_OK ||
-                        Jim_SetVariable(interp, varNamePtr, Jim_NewIntObj(interp,
-                                ++currentVal)) != JIM_OK) {
-                        goto evalnext;
-                    }
-                }
-            }
-        }
-        goto out;
-    }
-  evalstart:
-#endif
-
-    while (boolean && (retval == JIM_OK || retval == JIM_CONTINUE)) {
-
-        retval = Jim_EvalObj(interp, argv[4]);
-        if (JimCheckLoopRetcode(interp, retval)) {
-            immediate++;
-            break;
-        }
-        if (retval == JIM_OK || retval == JIM_CONTINUE) {
-
-JIM_IF_OPTIM(evalnext:)
-            retval = Jim_EvalObj(interp, argv[3]);
-            if (retval == JIM_OK || retval == JIM_CONTINUE) {
-
-JIM_IF_OPTIM(testcond:)
-                retval = Jim_GetBoolFromExpr(interp, argv[2], &boolean);
-            }
-        }
-    }
-JIM_IF_OPTIM(out:)
-    if (stopVarNamePtr) {
-        Jim_DecrRefCount(interp, stopVarNamePtr);
-    }
-    if (varNamePtr) {
-        Jim_DecrRefCount(interp, varNamePtr);
-    }
-
-    if (!immediate) {
-        if (retval == JIM_CONTINUE || retval == JIM_BREAK || retval == JIM_OK) {
-            Jim_SetEmptyResult(interp);
-            return JIM_OK;
-        }
-    }
-
-    return retval;
-}
-
-
-static int Jim_LoopCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int retval;
-    jim_wide i;
-    jim_wide limit = 0;
-    jim_wide incr = 1;
-    Jim_Obj *bodyObjPtr;
-
-    if (argc < 4 || argc > 6) {
-        Jim_WrongNumArgs(interp, 1, argv, "var ?first? limit ?incr? body");
-        return JIM_ERR;
-    }
-
-    retval = Jim_GetWideExpr(interp, argv[2], &i);
-    if (argc > 4 && retval == JIM_OK) {
-        retval = Jim_GetWideExpr(interp, argv[3], &limit);
-    }
-    if (argc > 5 && retval == JIM_OK) {
-        Jim_GetWideExpr(interp, argv[4], &incr);
-    }
-    if (retval != JIM_OK) {
-        return retval;
-    }
-    if (argc == 4) {
-        limit = i;
-        i = 0;
-    }
-    bodyObjPtr = argv[argc - 1];
-
-    retval = Jim_SetVariable(interp, argv[1], Jim_NewIntObj(interp, i));
-
-    while (((i < limit && incr > 0) || (i > limit && incr < 0)) && retval == JIM_OK) {
-        retval = Jim_EvalObj(interp, bodyObjPtr);
-        if (JimCheckLoopRetcode(interp, retval)) {
-            return retval;
-        }
-        if (retval == JIM_OK || retval == JIM_CONTINUE) {
-            Jim_Obj *objPtr = Jim_GetVariable(interp, argv[1], JIM_ERRMSG);
-
-            retval = JIM_OK;
-
-
-            i += incr;
-
-            if (objPtr && !Jim_IsShared(objPtr) && objPtr->typePtr == &intObjType) {
-                if (argv[1]->typePtr != &variableObjType) {
-                    if (Jim_SetVariable(interp, argv[1], objPtr) != JIM_OK) {
-                        return JIM_ERR;
-                    }
-                }
-                JimWideValue(objPtr) = i;
-                Jim_InvalidateStringRep(objPtr);
-
-                if (argv[1]->typePtr != &variableObjType) {
-                    if (Jim_SetVariable(interp, argv[1], objPtr) != JIM_OK) {
-                        retval = JIM_ERR;
-                        break;
-                    }
-                }
-            }
-            else {
-                objPtr = Jim_NewIntObj(interp, i);
-                retval = Jim_SetVariable(interp, argv[1], objPtr);
-                if (retval != JIM_OK) {
-                    Jim_FreeNewObj(interp, objPtr);
-                }
-            }
-        }
-    }
-
-    if (retval == JIM_OK || retval == JIM_CONTINUE || retval == JIM_BREAK) {
-        Jim_SetEmptyResult(interp);
-        return JIM_OK;
-    }
-    return retval;
-}
-
-typedef struct {
-    Jim_Obj *objPtr;
-    int idx;
-} Jim_ListIter;
-
-static void JimListIterInit(Jim_ListIter *iter, Jim_Obj *objPtr)
-{
-    iter->objPtr = objPtr;
-    iter->idx = 0;
-}
-
-static Jim_Obj *JimListIterNext(Jim_Interp *interp, Jim_ListIter *iter)
-{
-    if (iter->idx >= Jim_ListLength(interp, iter->objPtr)) {
-        return NULL;
-    }
-    return iter->objPtr->internalRep.listValue.ele[iter->idx++];
-}
-
-static int JimListIterDone(Jim_Interp *interp, Jim_ListIter *iter)
-{
-    return iter->idx >= Jim_ListLength(interp, iter->objPtr);
-}
-
-
-static int JimForeachMapHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int doMap)
-{
-    int result = JIM_OK;
-    int i, numargs;
-    Jim_ListIter twoiters[2];
-    Jim_ListIter *iters;
-    Jim_Obj *script;
-    Jim_Obj *resultObj;
-
-    if (argc < 4 || argc % 2 != 0) {
-        Jim_WrongNumArgs(interp, 1, argv, "varList list ?varList list ...? script");
-        return JIM_ERR;
-    }
-    script = argv[argc - 1];
-    numargs = (argc - 1 - 1);
-
-    if (numargs == 2) {
-        iters = twoiters;
-    }
-    else {
-        iters = Jim_Alloc(numargs * sizeof(*iters));
-    }
-    for (i = 0; i < numargs; i++) {
-        JimListIterInit(&iters[i], argv[i + 1]);
-        if (i % 2 == 0 && JimListIterDone(interp, &iters[i])) {
-            result = JIM_ERR;
-        }
-    }
-    if (result != JIM_OK) {
-        Jim_SetResultString(interp, "foreach varlist is empty", -1);
-        goto empty_varlist;
-    }
-
-    if (doMap) {
-        resultObj = Jim_NewListObj(interp, NULL, 0);
-    }
-    else {
-        resultObj = interp->emptyObj;
-    }
-    Jim_IncrRefCount(resultObj);
-
-    while (1) {
-
-        for (i = 0; i < numargs; i += 2) {
-            if (!JimListIterDone(interp, &iters[i + 1])) {
-                break;
-            }
-        }
-        if (i == numargs) {
-
-            break;
-        }
-
-
-        for (i = 0; i < numargs; i += 2) {
-            Jim_Obj *varName;
-
-
-            JimListIterInit(&iters[i], argv[i + 1]);
-            while ((varName = JimListIterNext(interp, &iters[i])) != NULL) {
-                Jim_Obj *valObj = JimListIterNext(interp, &iters[i + 1]);
-                if (!valObj) {
-
-                    valObj = interp->emptyObj;
-                }
-
-                Jim_IncrRefCount(valObj);
-                result = Jim_SetVariable(interp, varName, valObj);
-                Jim_DecrRefCount(interp, valObj);
-                if (result != JIM_OK) {
-                    goto err;
-                }
-            }
-        }
-        result = Jim_EvalObj(interp, script);
-        if (JimCheckLoopRetcode(interp, result)) {
-            goto err;
-        }
-        switch (result) {
-            case JIM_OK:
-                if (doMap) {
-                    Jim_ListAppendElement(interp, resultObj, interp->result);
-                }
-                break;
-            case JIM_CONTINUE:
-                break;
-            case JIM_BREAK:
-                goto out;
-            default:
-                goto err;
-        }
-    }
-  out:
-    result = JIM_OK;
-    Jim_SetResult(interp, resultObj);
-  err:
-    Jim_DecrRefCount(interp, resultObj);
-  empty_varlist:
-    if (numargs > 2) {
-        Jim_Free(iters);
-    }
-    return result;
-}
-
-
-static int Jim_ForeachCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return JimForeachMapHelper(interp, argc, argv, 0);
-}
-
-
-static int Jim_LmapCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return JimForeachMapHelper(interp, argc, argv, 1);
-}
-
-
-static int Jim_LassignCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int result = JIM_ERR;
-    int i;
-    Jim_ListIter iter;
-    Jim_Obj *resultObj;
-
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "varList list ?varName ...?");
-        return JIM_ERR;
-    }
-
-    JimListIterInit(&iter, argv[1]);
-
-    for (i = 2; i < argc; i++) {
-        Jim_Obj *valObj = JimListIterNext(interp, &iter);
-        result = Jim_SetVariable(interp, argv[i], valObj ? valObj : interp->emptyObj);
-        if (result != JIM_OK) {
-            return result;
-        }
-    }
-
-    resultObj = Jim_NewListObj(interp, NULL, 0);
-    while (!JimListIterDone(interp, &iter)) {
-        Jim_ListAppendElement(interp, resultObj, JimListIterNext(interp, &iter));
-    }
-
-    Jim_SetResult(interp, resultObj);
-
-    return JIM_OK;
-}
-
-
-static int Jim_IfCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int boolean, retval, current = 1, falsebody = 0;
-
-    if (argc >= 3) {
-        while (1) {
-
-            if (current >= argc)
-                goto err;
-            if ((retval = Jim_GetBoolFromExpr(interp, argv[current++], &boolean))
-                != JIM_OK)
-                return retval;
-
-            if (current >= argc)
-                goto err;
-            if (Jim_CompareStringImmediate(interp, argv[current], "then"))
-                current++;
-
-            if (current >= argc)
-                goto err;
-            if (boolean)
-                return Jim_EvalObj(interp, argv[current]);
-
-            if (++current >= argc) {
-                Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-                return JIM_OK;
-            }
-            falsebody = current++;
-            if (Jim_CompareStringImmediate(interp, argv[falsebody], "else")) {
-
-                if (current != argc - 1)
-                    goto err;
-                return Jim_EvalObj(interp, argv[current]);
-            }
-            else if (Jim_CompareStringImmediate(interp, argv[falsebody], "elseif"))
-                continue;
-
-            else if (falsebody != argc - 1)
-                goto err;
-            return Jim_EvalObj(interp, argv[falsebody]);
-        }
-        return JIM_OK;
-    }
-  err:
-    Jim_WrongNumArgs(interp, 1, argv, "condition ?then? trueBody ?elseif ...? ?else? falseBody");
-    return JIM_ERR;
-}
-
-
-int Jim_CommandMatchObj(Jim_Interp *interp, Jim_Obj *commandObj, Jim_Obj *patternObj,
-    Jim_Obj *stringObj, int flags)
-{
-    Jim_Obj *parms[5];
-    int argc = 0;
-    long eq;
-    int rc;
-
-    parms[argc++] = commandObj;
-    if (flags & JIM_NOCASE) {
-        parms[argc++] = Jim_NewStringObj(interp, "-nocase", -1);
-    }
-    if (flags & JIM_OPT_END) {
-        parms[argc++] = Jim_NewStringObj(interp, "--", -1);
-    }
-    parms[argc++] = patternObj;
-    parms[argc++] = stringObj;
-
-    rc = Jim_EvalObjVector(interp, argc, parms);
-
-    if (rc != JIM_OK || Jim_GetLong(interp, Jim_GetResult(interp), &eq) != JIM_OK) {
-        eq = -rc;
-    }
-
-    return eq;
-}
-
-
-static int Jim_SwitchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    enum { SWITCH_EXACT, SWITCH_GLOB, SWITCH_RE, SWITCH_CMD };
-    int matchOpt = SWITCH_EXACT, opt = 1, patCount, i;
-    int match_flags = 0;
-    Jim_Obj *command = NULL, *scriptObj = NULL, *strObj;
-    Jim_Obj **caseList;
-
-    if (argc < 3) {
-      wrongnumargs:
-        Jim_WrongNumArgs(interp, 1, argv, "?options? string "
-            "pattern body ... ?default body?   or   " "{pattern body ?pattern body ...?}");
-        return JIM_ERR;
-    }
-    for (opt = 1; opt < argc; ++opt) {
-        const char *option = Jim_String(argv[opt]);
-
-        if (*option != '-')
-            break;
-        else if (strncmp(option, "--", 2) == 0) {
-            ++opt;
-            break;
-        }
-        else if (strncmp(option, "-exact", 2) == 0)
-            matchOpt = SWITCH_EXACT;
-        else if (strncmp(option, "-glob", 2) == 0)
-            matchOpt = SWITCH_GLOB;
-        else if (strncmp(option, "-regexp", 2) == 0) {
-            matchOpt = SWITCH_RE;
-            match_flags |= JIM_OPT_END;
-        }
-        else if (strncmp(option, "-command", 2) == 0) {
-            matchOpt = SWITCH_CMD;
-            if ((argc - opt) < 2)
-                goto wrongnumargs;
-            command = argv[++opt];
-        }
-        else {
-            Jim_SetResultFormatted(interp,
-                "bad option \"%#s\": must be -exact, -glob, -regexp, -command procname or --",
-                argv[opt]);
-            return JIM_ERR;
-        }
-        if ((argc - opt) < 2)
-            goto wrongnumargs;
-    }
-    strObj = argv[opt++];
-    patCount = argc - opt;
-    if (patCount == 1) {
-        JimListGetElements(interp, argv[opt], &patCount, &caseList);
-    }
-    else
-        caseList = (Jim_Obj **)&argv[opt];
-    if (patCount == 0 || patCount % 2 != 0)
-        goto wrongnumargs;
-    for (i = 0; scriptObj == NULL && i < patCount; i += 2) {
-        Jim_Obj *patObj = caseList[i];
-
-        if (!Jim_CompareStringImmediate(interp, patObj, "default")
-            || i < (patCount - 2)) {
-            switch (matchOpt) {
-                case SWITCH_EXACT:
-                    if (Jim_StringEqObj(strObj, patObj))
-                        scriptObj = caseList[i + 1];
-                    break;
-                case SWITCH_GLOB:
-                    if (Jim_StringMatchObj(interp, patObj, strObj, 0))
-                        scriptObj = caseList[i + 1];
-                    break;
-                case SWITCH_RE:
-                    command = Jim_NewStringObj(interp, "regexp", -1);
-
-                case SWITCH_CMD:{
-                        int rc = Jim_CommandMatchObj(interp, command, patObj, strObj, match_flags);
-
-                        if (argc - opt == 1) {
-                            JimListGetElements(interp, argv[opt], &patCount, &caseList);
-                        }
-
-                        if (rc < 0) {
-                            return -rc;
-                        }
-                        if (rc)
-                            scriptObj = caseList[i + 1];
-                        break;
-                    }
-            }
-        }
-        else {
-            scriptObj = caseList[i + 1];
-        }
-    }
-    for (; i < patCount && Jim_CompareStringImmediate(interp, scriptObj, "-"); i += 2)
-        scriptObj = caseList[i + 1];
-    if (scriptObj && Jim_CompareStringImmediate(interp, scriptObj, "-")) {
-        Jim_SetResultFormatted(interp, "no body specified for pattern \"%#s\"", caseList[i - 2]);
-        return JIM_ERR;
-    }
-    Jim_SetEmptyResult(interp);
-    if (scriptObj) {
-        return Jim_EvalObj(interp, scriptObj);
-    }
-    return JIM_OK;
-}
-
-
-static int Jim_ListCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *listObjPtr;
-
-    listObjPtr = Jim_NewListObj(interp, argv + 1, argc - 1);
-    Jim_SetResult(interp, listObjPtr);
-    return JIM_OK;
-}
-
-
-static int Jim_LindexCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *objPtr;
-    int ret;
-
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "list ?index ...?");
-        return JIM_ERR;
-    }
-    ret = Jim_ListIndices(interp, argv[1], argv + 2, argc - 2, &objPtr, JIM_NONE);
-    if (ret < 0) {
-        ret = JIM_OK;
-        Jim_SetEmptyResult(interp);
-    }
-    else if (ret == JIM_OK) {
-        Jim_SetResult(interp, objPtr);
-    }
-    return ret;
-}
-
-
-static int Jim_LlengthCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    if (argc != 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "list");
-        return JIM_ERR;
-    }
-    Jim_SetResultInt(interp, Jim_ListLength(interp, argv[1]));
-    return JIM_OK;
-}
-
-
-static int Jim_LsearchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    static const char * const options[] = {
-        "-bool", "-not", "-nocase", "-exact", "-glob", "-regexp", "-all", "-inline", "-command",
-        "-stride", "-index", NULL
-    };
-    enum
-    { OPT_BOOL, OPT_NOT, OPT_NOCASE, OPT_EXACT, OPT_GLOB, OPT_REGEXP, OPT_ALL, OPT_INLINE,
-            OPT_COMMAND, OPT_STRIDE, OPT_INDEX };
-    int i;
-    int opt_bool = 0;
-    int opt_not = 0;
-    int opt_all = 0;
-    int opt_inline = 0;
-    int opt_match = OPT_EXACT;
-    int listlen;
-    int rc = JIM_OK;
-    Jim_Obj *listObjPtr = NULL;
-    Jim_Obj *commandObj = NULL;
-    Jim_Obj *indexObj = NULL;
-    int match_flags = 0;
-    long stride = 1;
-
-    if (argc < 3) {
-      wrongargs:
-        Jim_WrongNumArgs(interp, 1, argv,
-            "?-exact|-glob|-regexp|-command 'command'? ?-bool|-inline? ?-not? ?-nocase? ?-all? ?-stride len? ?-index val? list value");
-        return JIM_ERR;
-    }
-
-    for (i = 1; i < argc - 2; i++) {
-        int option;
-
-        if (Jim_GetEnum(interp, argv[i], options, &option, NULL, JIM_ERRMSG) != JIM_OK) {
-            return JIM_ERR;
-        }
-        switch (option) {
-            case OPT_BOOL:
-                opt_bool = 1;
-                opt_inline = 0;
-                break;
-            case OPT_NOT:
-                opt_not = 1;
-                break;
-            case OPT_NOCASE:
-                match_flags |= JIM_NOCASE;
-                break;
-            case OPT_INLINE:
-                opt_inline = 1;
-                opt_bool = 0;
-                break;
-            case OPT_ALL:
-                opt_all = 1;
-                break;
-            case OPT_REGEXP:
-                opt_match = option;
-                match_flags |= JIM_OPT_END;
-                break;
-            case OPT_COMMAND:
-                if (i >= argc - 2) {
-                    goto wrongargs;
-                }
-                commandObj = argv[++i];
-
-            case OPT_EXACT:
-            case OPT_GLOB:
-                opt_match = option;
-                break;
-            case OPT_INDEX:
-                if (i >= argc - 2) {
-                    goto wrongargs;
-                }
-                indexObj = argv[++i];
-                break;
-            case OPT_STRIDE:
-                if (i >= argc - 2) {
-                    goto wrongargs;
-                }
-                if (Jim_GetLong(interp, argv[++i], &stride) != JIM_OK) {
-                    return JIM_ERR;
-                }
-                if (stride < 1) {
-                    Jim_SetResultString(interp, "stride length must be at least 1", -1);
-                    return JIM_ERR;
-                }
-                break;
-        }
-    }
-
-    argc -= i;
-    if (argc < 2) {
-        goto wrongargs;
-    }
-    argv += i;
-
-    listlen = Jim_ListLength(interp, argv[0]);
-    if (listlen % stride) {
-        Jim_SetResultString(interp, "list size must be a multiple of the stride length", -1);
-        return JIM_ERR;
-    }
-
-    if (opt_all) {
-        listObjPtr = Jim_NewListObj(interp, NULL, 0);
-    }
-    if (opt_match == OPT_REGEXP) {
-        commandObj = Jim_NewStringObj(interp, "regexp", -1);
-    }
-    if (commandObj) {
-        Jim_IncrRefCount(commandObj);
-    }
-
-    for (i = 0; i < listlen; i += stride) {
-        int eq = 0;
-        Jim_Obj *searchListObj;
-        Jim_Obj *objPtr;
-        int offset;
-
-        if (indexObj) {
-            int indexlen = Jim_ListLength(interp, indexObj);
-            if (stride == 1) {
-                searchListObj = Jim_ListGetIndex(interp, argv[0], i);
-            }
-            else {
-                searchListObj = Jim_NewListObj(interp, argv[0]->internalRep.listValue.ele + i, stride);
-            }
-            Jim_IncrRefCount(searchListObj);
-            rc = Jim_ListIndices(interp, searchListObj, indexObj->internalRep.listValue.ele, indexlen, &objPtr, JIM_ERRMSG);
-            if (rc != JIM_OK) {
-                Jim_DecrRefCount(interp, searchListObj);
-                rc = JIM_ERR;
-                goto done;
-            }
-
-            offset = 0;
-        }
-        else {
-
-            searchListObj = argv[0];
-            offset = i;
-            objPtr = Jim_ListGetIndex(interp, searchListObj, i);
-            Jim_IncrRefCount(searchListObj);
-        }
-
-        switch (opt_match) {
-            case OPT_EXACT:
-                eq = Jim_StringCompareObj(interp, argv[1], objPtr, match_flags) == 0;
-                break;
-
-            case OPT_GLOB:
-                eq = Jim_StringMatchObj(interp, argv[1], objPtr, match_flags);
-                break;
-
-            case OPT_REGEXP:
-            case OPT_COMMAND:
-                eq = Jim_CommandMatchObj(interp, commandObj, argv[1], objPtr, match_flags);
-                if (eq < 0) {
-                    Jim_DecrRefCount(interp, searchListObj);
-                    rc = JIM_ERR;
-                    goto done;
-                }
-                break;
-        }
-
-
-        if ((!opt_bool && eq == !opt_not) || (opt_bool && (eq || opt_all))) {
-            Jim_Obj *resultObj;
-
-            if (opt_bool) {
-                resultObj = Jim_NewIntObj(interp, eq ^ opt_not);
-            }
-            else if (!opt_inline) {
-                resultObj = Jim_NewIntObj(interp, i);
-            }
-            else if (stride == 1) {
-                resultObj = objPtr;
-            }
-            else if (opt_all) {
-
-                ListInsertElements(listObjPtr, -1, stride,
-                    searchListObj->internalRep.listValue.ele + offset);
-
-                resultObj = NULL;
-            }
-            else {
-                resultObj = Jim_NewListObj(interp, searchListObj->internalRep.listValue.ele + offset, stride);
-            }
-
-            if (opt_all) {
-
-                if (stride == 1) {
-                    Jim_ListAppendElement(interp, listObjPtr, resultObj);
-                }
-            }
-            else {
-                Jim_SetResult(interp, resultObj);
-                Jim_DecrRefCount(interp, searchListObj);
-                goto done;
-            }
-        }
-        Jim_DecrRefCount(interp, searchListObj);
-    }
-
-    if (opt_all) {
-        Jim_SetResult(interp, listObjPtr);
-        listObjPtr = NULL;
-    }
-    else {
-
-        if (opt_bool) {
-            Jim_SetResultBool(interp, opt_not);
-        }
-        else if (!opt_inline) {
-            Jim_SetResultInt(interp, -1);
-        }
-    }
-
-  done:
-    if (listObjPtr) {
-        Jim_FreeNewObj(interp, listObjPtr);
-    }
-    if (commandObj) {
-        Jim_DecrRefCount(interp, commandObj);
-    }
-    return rc;
-}
-
-
-static int Jim_LappendCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *listObjPtr;
-    int new_obj = 0;
-    int i;
-
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "varName ?value value ...?");
-        return JIM_ERR;
-    }
-    listObjPtr = Jim_GetVariable(interp, argv[1], JIM_UNSHARED);
-    if (!listObjPtr) {
-
-        listObjPtr = Jim_NewListObj(interp, NULL, 0);
-        new_obj = 1;
-    }
-    else if (Jim_IsShared(listObjPtr)) {
-        listObjPtr = Jim_DuplicateObj(interp, listObjPtr);
-        new_obj = 1;
-    }
-    for (i = 2; i < argc; i++)
-        Jim_ListAppendElement(interp, listObjPtr, argv[i]);
-    if (Jim_SetVariable(interp, argv[1], listObjPtr) != JIM_OK) {
-        if (new_obj)
-            Jim_FreeNewObj(interp, listObjPtr);
-        return JIM_ERR;
-    }
-    Jim_SetResult(interp, listObjPtr);
-    return JIM_OK;
-}
-
-
-static int Jim_LinsertCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int idx, len;
-    Jim_Obj *listPtr;
-
-    if (argc < 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "list index ?element ...?");
-        return JIM_ERR;
-    }
-    listPtr = argv[1];
-    if (Jim_IsShared(listPtr))
-        listPtr = Jim_DuplicateObj(interp, listPtr);
-    if (Jim_GetIndex(interp, argv[2], &idx) != JIM_OK)
-        goto err;
-    len = Jim_ListLength(interp, listPtr);
-    if (idx >= len)
-        idx = len;
-    else if (idx < 0)
-        idx = len + idx + 1;
-    Jim_ListInsertElements(interp, listPtr, idx, argc - 3, &argv[3]);
-    Jim_SetResult(interp, listPtr);
-    return JIM_OK;
-  err:
-    if (listPtr != argv[1]) {
-        Jim_FreeNewObj(interp, listPtr);
-    }
-    return JIM_ERR;
-}
-
-
-static int Jim_LreplaceCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int first, last, len, rangeLen;
-    Jim_Obj *listObj;
-    Jim_Obj *newListObj;
-
-    if (argc < 4) {
-        Jim_WrongNumArgs(interp, 1, argv, "list first last ?element ...?");
-        return JIM_ERR;
-    }
-    if (Jim_GetIndex(interp, argv[2], &first) != JIM_OK ||
-        Jim_GetIndex(interp, argv[3], &last) != JIM_OK) {
-        return JIM_ERR;
-    }
-
-    listObj = argv[1];
-    len = Jim_ListLength(interp, listObj);
-
-    first = JimRelToAbsIndex(len, first);
-    last = JimRelToAbsIndex(len, last);
-    JimRelToAbsRange(len, &first, &last, &rangeLen);
-
-
-    if (first > len) {
-        first = len;
-    }
-
-
-    newListObj = Jim_NewListObj(interp, listObj->internalRep.listValue.ele, first);
-
-
-    ListInsertElements(newListObj, -1, argc - 4, argv + 4);
-
-
-    ListInsertElements(newListObj, -1, len - first - rangeLen, listObj->internalRep.listValue.ele + first + rangeLen);
-
-    Jim_SetResult(interp, newListObj);
-    return JIM_OK;
-}
-
-
-static int Jim_LsetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    if (argc < 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "listVar ?index ...? value");
-        return JIM_ERR;
-    }
-    else if (argc == 3) {
-
-        if (Jim_SetVariable(interp, argv[1], argv[2]) != JIM_OK)
-            return JIM_ERR;
-        Jim_SetResult(interp, argv[2]);
-        return JIM_OK;
-    }
-    return Jim_ListSetIndex(interp, argv[1], argv + 2, argc - 3, argv[argc - 1]);
-}
-
-
-static int Jim_LsortCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const argv[])
-{
-    static const char * const options[] = {
-        "-ascii", "-nocase", "-increasing", "-decreasing", "-command", "-integer", "-real", "-index", "-unique",
-        "-stride", "-dictionary", NULL
-    };
-    enum {
-        OPT_ASCII, OPT_NOCASE, OPT_INCREASING, OPT_DECREASING, OPT_COMMAND, OPT_INTEGER, OPT_REAL, OPT_INDEX, OPT_UNIQUE,
-        OPT_STRIDE, OPT_DICT
-    };
-    Jim_Obj *resObj;
-    int i;
-    int retCode;
-    int shared;
-    long stride = 1;
-    Jim_Obj **elements;
-    int listlen;
-
-    struct lsort_info info;
-
-    if (argc < 2) {
-wrongargs:
-        Jim_WrongNumArgs(interp, 1, argv, "?options? list");
-        return JIM_ERR;
-    }
-
-    info.type = JIM_LSORT_ASCII;
-    info.order = 1;
-    info.indexc = 0;
-    info.unique = 0;
-    info.command = NULL;
-    info.interp = interp;
-
-    for (i = 1; i < (argc - 1); i++) {
-        int option;
-
-        if (Jim_GetEnum(interp, argv[i], options, &option, NULL, JIM_ENUM_ABBREV | JIM_ERRMSG)
-            != JIM_OK)
-            return JIM_ERR;
-        switch (option) {
-            case OPT_ASCII:
-                info.type = JIM_LSORT_ASCII;
-                break;
-            case OPT_DICT:
-                info.type = JIM_LSORT_DICT;
-                break;
-            case OPT_NOCASE:
-                info.type = JIM_LSORT_NOCASE;
-                break;
-            case OPT_INTEGER:
-                info.type = JIM_LSORT_INTEGER;
-                break;
-            case OPT_REAL:
-                info.type = JIM_LSORT_REAL;
-                break;
-            case OPT_INCREASING:
-                info.order = 1;
-                break;
-            case OPT_DECREASING:
-                info.order = -1;
-                break;
-            case OPT_UNIQUE:
-                info.unique = 1;
-                break;
-            case OPT_COMMAND:
-                if (i >= (argc - 2)) {
-                    Jim_SetResultString(interp, "\"-command\" option must be followed by comparison command", -1);
-                    return JIM_ERR;
-                }
-                info.type = JIM_LSORT_COMMAND;
-                info.command = argv[i + 1];
-                i++;
-                break;
-            case OPT_STRIDE:
-                if (i >= argc - 2) {
-                    goto wrongargs;
-                }
-                if (Jim_GetLong(interp, argv[++i], &stride) != JIM_OK) {
-                    return JIM_ERR;
-                }
-                if (stride < 2) {
-                    Jim_SetResultString(interp, "stride length must be at least 2", -1);
-                    return JIM_ERR;
-                }
-                break;
-            case OPT_INDEX:
-                if (i >= (argc - 2)) {
-badindex:
-                    Jim_SetResultString(interp, "\"-index\" option must be followed by list index", -1);
-                    return JIM_ERR;
-                }
-                JimListGetElements(interp, argv[i + 1], &info.indexc, &info.indexv);
-                if (info.indexc == 0) {
-                    goto badindex;
-                }
-                i++;
-                break;
-        }
-    }
-    resObj = argv[argc - 1];
-    JimListGetElements(interp, resObj, &listlen, &elements);
-    if (listlen <= 1) {
-
-        Jim_SetResult(interp, resObj);
-        return JIM_OK;
-    }
-
-    if (stride > 1) {
-        Jim_Obj *tmpListObj;
-        int i;
-
-        if (listlen % stride) {
-            Jim_SetResultString(interp, "list size must be a multiple of the stride length", -1);
-            return JIM_ERR;
-        }
-
-        tmpListObj = Jim_NewListObj(interp, NULL, 0);
-        Jim_IncrRefCount(tmpListObj);
-        for (i = 0; i < listlen; i += stride) {
-            Jim_ListAppendElement(interp, tmpListObj, Jim_NewListObj(interp, elements + i, stride));
-        }
-        retCode = ListSortElements(interp, tmpListObj, &info);
-        if (retCode == JIM_OK) {
-            resObj = Jim_NewListObj(interp, NULL, 0);
-
-            for (i = 0; i < listlen; i += stride) {
-                Jim_ListAppendList(interp, resObj, Jim_ListGetIndex(interp, tmpListObj, i / stride));
-            }
-            Jim_SetResult(interp, resObj);
-        }
-        Jim_DecrRefCount(interp, tmpListObj);
-    }
-    else {
-        if ((shared = Jim_IsShared(resObj))) {
-            resObj = Jim_DuplicateObj(interp, resObj);
-        }
-        retCode = ListSortElements(interp, resObj, &info);
-        if (retCode == JIM_OK) {
-            Jim_SetResult(interp, resObj);
-        }
-        else if (shared) {
-            Jim_FreeNewObj(interp, resObj);
-        }
-    }
-    return retCode;
-}
-
-
-static int Jim_AppendCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *stringObjPtr;
-    int i;
-
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "varName ?value ...?");
-        return JIM_ERR;
-    }
-    if (argc == 2) {
-        stringObjPtr = Jim_GetVariable(interp, argv[1], JIM_ERRMSG);
-        if (!stringObjPtr)
-            return JIM_ERR;
-    }
-    else {
-        int new_obj = 0;
-        stringObjPtr = Jim_GetVariable(interp, argv[1], JIM_UNSHARED);
-        if (!stringObjPtr) {
-
-            stringObjPtr = Jim_NewEmptyStringObj(interp);
-            new_obj = 1;
-        }
-        else if (Jim_IsShared(stringObjPtr)) {
-            new_obj = 1;
-            stringObjPtr = Jim_DuplicateObj(interp, stringObjPtr);
-        }
-        for (i = 2; i < argc; i++) {
-            Jim_AppendObj(interp, stringObjPtr, argv[i]);
-        }
-        if (Jim_SetVariable(interp, argv[1], stringObjPtr) != JIM_OK) {
-            if (new_obj) {
-                Jim_FreeNewObj(interp, stringObjPtr);
-            }
-            return JIM_ERR;
-        }
-    }
-    Jim_SetResult(interp, stringObjPtr);
-    return JIM_OK;
-}
-
-
-
-
-
-static int Jim_EvalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int rc;
-
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "arg ?arg ...?");
-        return JIM_ERR;
-    }
-
-    if (argc == 2) {
-        rc = Jim_EvalObj(interp, argv[1]);
-    }
-    else {
-        rc = Jim_EvalObj(interp, Jim_ConcatObj(interp, argc - 1, argv + 1));
-    }
-
-    return rc;
-}
-
-
-static int Jim_UplevelCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    if (argc >= 2) {
-        int retcode;
-        Jim_CallFrame *savedCallFrame, *targetCallFrame;
-        const char *str;
-
-
-        savedCallFrame = interp->framePtr;
-
-
-        str = Jim_String(argv[1]);
-        if ((str[0] >= '0' && str[0] <= '9') || str[0] == '#') {
-            targetCallFrame = Jim_GetCallFrameByLevel(interp, argv[1]);
-            argc--;
-            argv++;
-        }
-        else {
-            targetCallFrame = Jim_GetCallFrameByLevel(interp, NULL);
-        }
-        if (targetCallFrame == NULL) {
-            return JIM_ERR;
-        }
-        if (argc < 2) {
-            Jim_WrongNumArgs(interp, 1, argv - 1, "?level? command ?arg ...?");
-            return JIM_ERR;
-        }
-
-        interp->framePtr = targetCallFrame;
-        if (argc == 2) {
-            retcode = Jim_EvalObj(interp, argv[1]);
-        }
-        else {
-            retcode = Jim_EvalObj(interp, Jim_ConcatObj(interp, argc - 1, argv + 1));
-        }
-        interp->framePtr = savedCallFrame;
-        return retcode;
-    }
-    else {
-        Jim_WrongNumArgs(interp, 1, argv, "?level? command ?arg ...?");
-        return JIM_ERR;
-    }
-}
-
-
-static int Jim_ExprCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int retcode;
-
-    if (argc == 2) {
-        retcode = Jim_EvalExpression(interp, argv[1]);
-    }
-#ifndef JIM_COMPAT
-    else {
-        Jim_WrongNumArgs(interp, 1, argv, "expression");
-        retcode = JIM_ERR;
-    }
-#else
-    else if (argc > 2) {
-        Jim_Obj *objPtr;
-
-        objPtr = Jim_ConcatObj(interp, argc - 1, argv + 1);
-        Jim_IncrRefCount(objPtr);
-        retcode = Jim_EvalExpression(interp, objPtr);
-        Jim_DecrRefCount(interp, objPtr);
-    }
-    else {
-        Jim_WrongNumArgs(interp, 1, argv, "expression ?...?");
-        return JIM_ERR;
-    }
-#endif
-    return retcode;
-}
-
-static int JimBreakContinueHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int retcode)
-{
-    if (argc != 1 && argc != 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "?level?");
-        return JIM_ERR;
-    }
-    if (argc == 2) {
-        long level;
-        int ret = Jim_GetLong(interp, argv[1], &level);
-        if (ret != JIM_OK) {
-            return ret;
-        }
-        interp->break_level = level;
-    }
-    return retcode;
-}
-
-
-static int Jim_BreakCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return JimBreakContinueHelper(interp, argc, argv, JIM_BREAK);
-}
-
-
-static int Jim_ContinueCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return JimBreakContinueHelper(interp, argc, argv, JIM_CONTINUE);
-}
-
-
-static int Jim_StacktraceCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *listObj;
-    int i;
-    jim_wide skip = 0;
-    jim_wide last = 0;
-
-    if (argc > 1) {
-        if (Jim_GetWideExpr(interp, argv[1], &skip) != JIM_OK) {
-            return JIM_ERR;
-        }
-    }
-    if (argc > 2) {
-        if (Jim_GetWideExpr(interp, argv[2], &last) != JIM_OK) {
-            return JIM_ERR;
-        }
-    }
-
-    listObj = Jim_NewListObj(interp, NULL, 0);
-    for (i = skip; i <= interp->procLevel; i++) {
-        Jim_EvalFrame *frame = JimGetEvalFrameByProcLevel(interp, -i);
-        if (frame->procLevel < last) {
-            break;
-        }
-        JimAddStackFrame(interp, frame, listObj);
-    }
-    Jim_SetResult(interp, listObj);
-    return JIM_OK;
-}
-
-
-static int Jim_ReturnCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int i;
-    Jim_Obj *stackTraceObj = NULL;
-    Jim_Obj *errorCodeObj = NULL;
-    int returnCode = JIM_OK;
-    long level = 1;
-
-    for (i = 1; i < argc - 1; i += 2) {
-        if (Jim_CompareStringImmediate(interp, argv[i], "-code")) {
-            if (Jim_GetReturnCode(interp, argv[i + 1], &returnCode) == JIM_ERR) {
-                return JIM_ERR;
-            }
-        }
-        else if (Jim_CompareStringImmediate(interp, argv[i], "-errorinfo")) {
-            stackTraceObj = argv[i + 1];
-        }
-        else if (Jim_CompareStringImmediate(interp, argv[i], "-errorcode")) {
-            errorCodeObj = argv[i + 1];
-        }
-        else if (Jim_CompareStringImmediate(interp, argv[i], "-level")) {
-            if (Jim_GetLong(interp, argv[i + 1], &level) != JIM_OK || level < 0) {
-                Jim_SetResultFormatted(interp, "bad level \"%#s\"", argv[i + 1]);
-                return JIM_ERR;
-            }
-        }
-        else {
-            break;
-        }
-    }
-
-    if (i != argc - 1 && i != argc) {
-        Jim_WrongNumArgs(interp, 1, argv,
-            "?-code code? ?-errorinfo stacktrace? ?-level level? ?result?");
-    }
-
-
-    if (stackTraceObj && returnCode == JIM_ERR) {
-        JimSetStackTrace(interp, stackTraceObj);
-    }
-
-    if (errorCodeObj && returnCode == JIM_ERR) {
-        Jim_SetGlobalVariableStr(interp, "errorCode", errorCodeObj);
-    }
-    interp->returnCode = returnCode;
-    interp->returnLevel = level;
-
-    if (i == argc - 1) {
-        Jim_SetResult(interp, argv[i]);
-    }
-    return level == 0 ? returnCode : JIM_RETURN;
-}
-
-
-static int Jim_TailcallCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    if (interp->framePtr->level == 0) {
-        Jim_SetResultString(interp, "tailcall can only be called from a proc or lambda", -1);
-        return JIM_ERR;
-    }
-    else if (argc >= 2) {
-
-        Jim_CallFrame *cf = interp->framePtr->parent;
-
-        Jim_Cmd *cmdPtr = Jim_GetCommand(interp, argv[1], JIM_ERRMSG);
-        if (cmdPtr == NULL) {
-            return JIM_ERR;
-        }
-
-        JimPanic((cf->tailcallCmd != NULL, "Already have a tailcallCmd"));
-
-
-        JimIncrCmdRefCount(cmdPtr);
-        cf->tailcallCmd = cmdPtr;
-
-
-        JimPanic((cf->tailcallObj != NULL, "Already have a tailcallobj"));
-
-        cf->tailcallObj = Jim_NewListObj(interp, argv + 1, argc - 1);
-        Jim_IncrRefCount(cf->tailcallObj);
-
-
-        return JIM_EVAL;
-    }
-    return JIM_OK;
-}
-
-static int JimAliasCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *cmdList;
-    Jim_Obj *prefixListObj = Jim_CmdPrivData(interp);
-
-
-    cmdList = Jim_DuplicateObj(interp, prefixListObj);
-    Jim_ListInsertElements(interp, cmdList, Jim_ListLength(interp, cmdList), argc - 1, argv + 1);
-
-    return JimEvalObjList(interp, cmdList);
-}
-
-static void JimAliasCmdDelete(Jim_Interp *interp, void *privData)
-{
-    Jim_Obj *prefixListObj = privData;
-    Jim_DecrRefCount(interp, prefixListObj);
-}
-
-static int Jim_AliasCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *prefixListObj;
-
-    if (argc < 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "newname command ?args ...?");
-        return JIM_ERR;
-    }
-
-    prefixListObj = Jim_NewListObj(interp, argv + 2, argc - 2);
-    Jim_IncrRefCount(prefixListObj);
-    Jim_SetResult(interp, argv[1]);
-
-    return Jim_CreateCommandObj(interp, argv[1], JimAliasCmd, prefixListObj, JimAliasCmdDelete);
-}
-
-
-static int Jim_ProcCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Cmd *cmd;
-
-    if (argc != 4 && argc != 5) {
-        Jim_WrongNumArgs(interp, 1, argv, "name arglist ?statics? body");
-        return JIM_ERR;
-    }
-
-    if (argc == 4) {
-        cmd = JimCreateProcedureCmd(interp, argv[2], NULL, argv[3], NULL);
-    }
-    else {
-        cmd = JimCreateProcedureCmd(interp, argv[2], argv[3], argv[4], NULL);
-    }
-
-    if (cmd) {
-
-        Jim_Obj *nameObjPtr = JimQualifyName(interp, argv[1]);
-        JimCreateCommand(interp, nameObjPtr, cmd);
-
-
-        JimUpdateProcNamespace(interp, cmd, nameObjPtr);
-        Jim_DecrRefCount(interp, nameObjPtr);
-
-
-        Jim_SetResult(interp, argv[1]);
-        return JIM_OK;
-    }
-    return JIM_ERR;
-}
-
-
-static int Jim_XtraceCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    if (argc != 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "callback");
-        return JIM_ERR;
-    }
-
-    if (interp->traceCmdObj) {
-        Jim_DecrRefCount(interp, interp->traceCmdObj);
-        interp->traceCmdObj = NULL;
-    }
-
-    if (Jim_Length(argv[1])) {
-
-        interp->traceCmdObj = argv[1];
-        Jim_IncrRefCount(interp->traceCmdObj);
-    }
-    return JIM_OK;
-}
-
-
-static int Jim_LocalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int retcode;
-
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "cmd ?args ...?");
-        return JIM_ERR;
-    }
-
-
-    interp->local++;
-    retcode = Jim_EvalObjVector(interp, argc - 1, argv + 1);
-    interp->local--;
-
-
-
-    if (retcode == 0) {
-        Jim_Obj *cmdNameObj = Jim_GetResult(interp);
-
-        if (Jim_GetCommand(interp, cmdNameObj, JIM_ERRMSG) == NULL) {
-            return JIM_ERR;
-        }
-        if (interp->framePtr->localCommands == NULL) {
-            interp->framePtr->localCommands = Jim_Alloc(sizeof(*interp->framePtr->localCommands));
-            Jim_InitStack(interp->framePtr->localCommands);
-        }
-        Jim_IncrRefCount(cmdNameObj);
-        Jim_StackPush(interp->framePtr->localCommands, cmdNameObj);
-    }
-
-    return retcode;
-}
-
-
-static int Jim_UpcallCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "cmd ?args ...?");
-        return JIM_ERR;
-    }
-    else {
-        int retcode;
-
-        Jim_Cmd *cmdPtr = Jim_GetCommand(interp, argv[1], JIM_ERRMSG);
-        if (cmdPtr == NULL || !cmdPtr->isproc || !cmdPtr->prevCmd) {
-            Jim_SetResultFormatted(interp, "no previous command: \"%#s\"", argv[1]);
-            return JIM_ERR;
-        }
-
-        cmdPtr->u.proc.upcall++;
-        JimIncrCmdRefCount(cmdPtr);
-
-
-        retcode = Jim_EvalObjVector(interp, argc - 1, argv + 1);
-
-
-        cmdPtr->u.proc.upcall--;
-        JimDecrCmdRefCount(interp, cmdPtr);
-
-        return retcode;
-    }
-}
-
-
-static int Jim_ApplyCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "lambdaExpr ?arg ...?");
-        return JIM_ERR;
-    }
-    else {
-        int ret;
-        Jim_Cmd *cmd;
-        Jim_Obj *argListObjPtr;
-        Jim_Obj *bodyObjPtr;
-        Jim_Obj *nsObj = NULL;
-        Jim_Obj **nargv;
-
-        int len = Jim_ListLength(interp, argv[1]);
-        if (len != 2 && len != 3) {
-            Jim_SetResultFormatted(interp, "can't interpret \"%#s\" as a lambda expression", argv[1]);
-            return JIM_ERR;
-        }
-
-        if (len == 3) {
-#ifdef jim_ext_namespace
-
-            nsObj = Jim_ListGetIndex(interp, argv[1], 2);
-#else
-            Jim_SetResultString(interp, "namespaces not enabled", -1);
-            return JIM_ERR;
-#endif
-        }
-        argListObjPtr = Jim_ListGetIndex(interp, argv[1], 0);
-        bodyObjPtr = Jim_ListGetIndex(interp, argv[1], 1);
-
-        cmd = JimCreateProcedureCmd(interp, argListObjPtr, NULL, bodyObjPtr, nsObj);
-
-        if (cmd) {
-
-            nargv = Jim_Alloc((argc - 2 + 1) * sizeof(*nargv));
-            nargv[0] = Jim_NewStringObj(interp, "apply lambdaExpr", -1);
-            Jim_IncrRefCount(nargv[0]);
-            memcpy(&nargv[1], argv + 2, (argc - 2) * sizeof(*nargv));
-            ret = JimCallProcedure(interp, cmd, argc - 2 + 1, nargv);
-            Jim_DecrRefCount(interp, nargv[0]);
-            Jim_Free(nargv);
-
-            JimDecrCmdRefCount(interp, cmd);
-            return ret;
-        }
-        return JIM_ERR;
-    }
-}
-
-
-
-static int Jim_ConcatCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_SetResult(interp, Jim_ConcatObj(interp, argc - 1, argv + 1));
-    return JIM_OK;
-}
-
-
-static int Jim_UpvarCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int i;
-    Jim_CallFrame *targetCallFrame;
-
-
-    if (argc > 3 && (argc % 2 == 0)) {
-        targetCallFrame = Jim_GetCallFrameByLevel(interp, argv[1]);
-        argc--;
-        argv++;
-    }
-    else {
-        targetCallFrame = Jim_GetCallFrameByLevel(interp, NULL);
-    }
-    if (targetCallFrame == NULL) {
-        return JIM_ERR;
-    }
-
-
-    if (argc < 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "?level? otherVar localVar ?otherVar localVar ...?");
-        return JIM_ERR;
-    }
-
-
-    for (i = 1; i < argc; i += 2) {
-        if (Jim_SetVariableLink(interp, argv[i + 1], argv[i], targetCallFrame) != JIM_OK)
-            return JIM_ERR;
-    }
-    return JIM_OK;
-}
-
-
-static int Jim_GlobalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int i;
-
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "varName ?varName ...?");
-        return JIM_ERR;
-    }
-
-    if (interp->framePtr->level == 0)
-        return JIM_OK;
-    for (i = 1; i < argc; i++) {
-
-        const char *name = Jim_String(argv[i]);
-        if (name[0] != ':' || name[1] != ':') {
-            if (Jim_SetVariableLink(interp, argv[i], argv[i], interp->topFramePtr) != JIM_OK)
-                return JIM_ERR;
-        }
-    }
-    return JIM_OK;
-}
-
-static Jim_Obj *JimStringMap(Jim_Interp *interp, Jim_Obj *mapListObjPtr,
-    Jim_Obj *objPtr, int nocase)
-{
-    int numMaps;
-    const char *str, *noMatchStart = NULL;
-    int strLen, i;
-    Jim_Obj *resultObjPtr;
-
-    numMaps = Jim_ListLength(interp, mapListObjPtr);
-    if (numMaps % 2) {
-        Jim_SetResultString(interp, "list must contain an even number of elements", -1);
-        return NULL;
-    }
-
-    str = Jim_String(objPtr);
-    strLen = Jim_Utf8Length(interp, objPtr);
-
-
-    resultObjPtr = Jim_NewStringObj(interp, "", 0);
-    while (strLen) {
-        for (i = 0; i < numMaps; i += 2) {
-            Jim_Obj *eachObjPtr;
-            const char *k;
-            int kl;
-
-            eachObjPtr = Jim_ListGetIndex(interp, mapListObjPtr, i);
-            k = Jim_String(eachObjPtr);
-            kl = Jim_Utf8Length(interp, eachObjPtr);
-
-            if (strLen >= kl && kl) {
-                int rc;
-                rc = JimStringCompareUtf8(str, kl, k, kl, nocase);
-                if (rc == 0) {
-                    if (noMatchStart) {
-                        Jim_AppendString(interp, resultObjPtr, noMatchStart, str - noMatchStart);
-                        noMatchStart = NULL;
-                    }
-                    Jim_AppendObj(interp, resultObjPtr, Jim_ListGetIndex(interp, mapListObjPtr, i + 1));
-                    str += utf8_index(str, kl);
-                    strLen -= kl;
-                    break;
-                }
-            }
-        }
-        if (i == numMaps) {
-            int c;
-            if (noMatchStart == NULL)
-                noMatchStart = str;
-            str += utf8_tounicode(str, &c);
-            strLen--;
-        }
-    }
-    if (noMatchStart) {
-        Jim_AppendString(interp, resultObjPtr, noMatchStart, str - noMatchStart);
-    }
-    return resultObjPtr;
-}
-
-
-static int Jim_StringCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int len;
-    int opt_case = 1;
-    int option;
-    static const char * const nocase_options[] = {
-        "-nocase", NULL
-    };
-    static const char * const nocase_length_options[] = {
-        "-nocase", "-length", NULL
-    };
-
-    enum {
-        OPT_BYTELENGTH,
-        OPT_BYTERANGE,
-        OPT_CAT,
-        OPT_COMPARE,
-        OPT_EQUAL,
-        OPT_FIRST,
-        OPT_INDEX,
-        OPT_IS,
-        OPT_LAST,
-        OPT_LENGTH,
-        OPT_MAP,
-        OPT_MATCH,
-        OPT_RANGE,
-        OPT_REPEAT,
-        OPT_REPLACE,
-        OPT_REVERSE,
-        OPT_TOLOWER,
-        OPT_TOTITLE,
-        OPT_TOUPPER,
-        OPT_TRIM,
-        OPT_TRIMLEFT,
-        OPT_TRIMRIGHT,
-        OPT_COUNT
-    };
-    static const jim_subcmd_type cmds[OPT_COUNT + 1] = {
-        JIM_DEF_SUBCMD("bytelength", "string", 1, 1),
-        JIM_DEF_SUBCMD("byterange", "string first last", 3, 3),
-        JIM_DEF_SUBCMD("cat", "?...?", 0, -1),
-        JIM_DEF_SUBCMD("compare", "?-nocase? ?-length int? string1 string2", 2, 5),
-        JIM_DEF_SUBCMD("equal", "?-nocase? ?-length int? string1 string2", 2, 5),
-        JIM_DEF_SUBCMD("first", "subString string ?index?", 2, 3),
-        JIM_DEF_SUBCMD("index", "string index", 2, 2),
-        JIM_DEF_SUBCMD("is", "class ?-strict? str", 2, 3),
-        JIM_DEF_SUBCMD("last", "subString string ?index?", 2, 3),
-        JIM_DEF_SUBCMD("length","string", 1, 1),
-        JIM_DEF_SUBCMD("map", "?-nocase? mapList string", 2, 3),
-        JIM_DEF_SUBCMD("match", "?-nocase? pattern string", 2, 3),
-        JIM_DEF_SUBCMD("range", "string first last", 3, 3),
-        JIM_DEF_SUBCMD("repeat", "string count", 2, 2),
-        JIM_DEF_SUBCMD("replace", "string first last ?string?", 3, 4),
-        JIM_DEF_SUBCMD("reverse", "string", 1, 1),
-        JIM_DEF_SUBCMD("tolower", "string", 1, 1),
-        JIM_DEF_SUBCMD("totitle", "string", 1, 1),
-        JIM_DEF_SUBCMD("toupper", "string", 1, 1),
-        JIM_DEF_SUBCMD("trim", "string ?trimchars?", 1, 2),
-        JIM_DEF_SUBCMD("trimleft", "string ?trimchars?", 1, 2),
-        JIM_DEF_SUBCMD("trimright", "string ?trimchars?", 1, 2),
-        { NULL }
-    };
-    const jim_subcmd_type *ct = Jim_ParseSubCmd(interp, cmds, argc, argv);
-    if (!ct) {
-        return JIM_ERR;
-    }
-    if (ct->function) {
-
-        return ct->function(interp, argc, argv);
-    }
-
-    option = ct - cmds;
-
-    switch (option) {
-        case OPT_LENGTH:
-            Jim_SetResultInt(interp, Jim_Utf8Length(interp, argv[2]));
-            return JIM_OK;
-
-        case OPT_BYTELENGTH:
-            Jim_SetResultInt(interp, Jim_Length(argv[2]));
-            return JIM_OK;
-
-        case OPT_CAT:{
-                Jim_Obj *objPtr;
-                if (argc == 3) {
-
-                    objPtr = argv[2];
-                }
-                else {
-                    int i;
-
-                    objPtr = Jim_NewStringObj(interp, "", 0);
-
-                    for (i = 2; i < argc; i++) {
-                        Jim_AppendObj(interp, objPtr, argv[i]);
-                    }
-                }
-                Jim_SetResult(interp, objPtr);
-                return JIM_OK;
-            }
-
-        case OPT_COMPARE:
-        case OPT_EQUAL:
-            {
-
-                long opt_length = -1;
-                int n = argc - 4;
-                int i = 2;
-                while (n > 0) {
-                    int subopt;
-                    if (Jim_GetEnum(interp, argv[i++], nocase_length_options, &subopt, NULL,
-                            JIM_ENUM_ABBREV) != JIM_OK) {
-badcompareargs:
-                        Jim_SubCmdArgError(interp, ct, argv[0]);
-                        return JIM_ERR;
-                    }
-                    if (subopt == 0) {
-
-                        opt_case = 0;
-                        n--;
-                    }
-                    else {
-
-                        if (n < 2) {
-                            goto badcompareargs;
-                        }
-                        if (Jim_GetLong(interp, argv[i++], &opt_length) != JIM_OK) {
-                            return JIM_ERR;
-                        }
-                        n -= 2;
-                    }
-                }
-                if (n) {
-                    goto badcompareargs;
-                }
-                argv += argc - 2;
-                if (opt_length < 0 && option != OPT_COMPARE && opt_case) {
-
-                    Jim_SetResultBool(interp, Jim_StringEqObj(argv[0], argv[1]));
-                }
-                else {
-                    const char *s1 = Jim_String(argv[0]);
-                    int l1 = Jim_Utf8Length(interp, argv[0]);
-                    const char *s2 = Jim_String(argv[1]);
-                    int l2 = Jim_Utf8Length(interp, argv[1]);
-                    if (opt_length >= 0) {
-                        if (l1 > opt_length) {
-                            l1 = opt_length;
-                        }
-                        if (l2 > opt_length) {
-                            l2 = opt_length;
-                        }
-                    }
-                    n = JimStringCompareUtf8(s1, l1, s2, l2, !opt_case);
-                    Jim_SetResultInt(interp, option == OPT_COMPARE ? n : n == 0);
-                }
-                return JIM_OK;
-            }
-
-        case OPT_MATCH:
-            if (argc != 4 &&
-                (argc != 5 ||
-                    Jim_GetEnum(interp, argv[2], nocase_options, &opt_case, NULL,
-                        JIM_ENUM_ABBREV) != JIM_OK)) {
-                Jim_WrongNumArgs(interp, 2, argv, "?-nocase? pattern string");
-                return JIM_ERR;
-            }
-            if (opt_case == 0) {
-                argv++;
-            }
-            Jim_SetResultBool(interp, Jim_StringMatchObj(interp, argv[2], argv[3], !opt_case));
-            return JIM_OK;
-
-        case OPT_MAP:{
-                Jim_Obj *objPtr;
-
-                if (argc != 4 &&
-                    (argc != 5 ||
-                        Jim_GetEnum(interp, argv[2], nocase_options, &opt_case, NULL,
-                            JIM_ENUM_ABBREV) != JIM_OK)) {
-                    Jim_WrongNumArgs(interp, 2, argv, "?-nocase? mapList string");
-                    return JIM_ERR;
-                }
-
-                if (opt_case == 0) {
-                    argv++;
-                }
-                objPtr = JimStringMap(interp, argv[2], argv[3], !opt_case);
-                if (objPtr == NULL) {
-                    return JIM_ERR;
-                }
-                Jim_SetResult(interp, objPtr);
-                return JIM_OK;
-            }
-
-        case OPT_RANGE:{
-                Jim_Obj *objPtr = Jim_StringRangeObj(interp, argv[2], argv[3], argv[4]);
-                if (objPtr == NULL) {
-                    return JIM_ERR;
-                }
-                Jim_SetResult(interp, objPtr);
-                return JIM_OK;
-            }
-
-        case OPT_BYTERANGE:{
-                Jim_Obj *objPtr = Jim_StringByteRangeObj(interp, argv[2], argv[3], argv[4]);
-                if (objPtr == NULL) {
-                    return JIM_ERR;
-                }
-                Jim_SetResult(interp, objPtr);
-                return JIM_OK;
-            }
-
-        case OPT_REPLACE:{
-                Jim_Obj *objPtr = JimStringReplaceObj(interp, argv[2], argv[3], argv[4], argc == 6 ? argv[5] : NULL);
-                if (objPtr == NULL) {
-                    return JIM_ERR;
-                }
-                Jim_SetResult(interp, objPtr);
-                return JIM_OK;
-            }
-
-
-        case OPT_REPEAT:{
-                Jim_Obj *objPtr;
-                jim_wide count;
-
-                if (Jim_GetWideExpr(interp, argv[3], &count) != JIM_OK) {
-                    return JIM_ERR;
-                }
-                objPtr = Jim_NewStringObj(interp, "", 0);
-                if (count > 0) {
-                    while (count--) {
-                        Jim_AppendObj(interp, objPtr, argv[2]);
-                    }
-                }
-                Jim_SetResult(interp, objPtr);
-                return JIM_OK;
-            }
-
-        case OPT_REVERSE:{
-                char *buf, *p;
-                const char *str;
-                int i;
-
-                str = Jim_GetString(argv[2], &len);
-                buf = Jim_Alloc(len + 1);
-                assert(buf);
-                p = buf + len;
-                *p = 0;
-                for (i = 0; i < len; ) {
-                    int c;
-                    int l = utf8_tounicode(str, &c);
-                    memcpy(p - l, str, l);
-                    p -= l;
-                    i += l;
-                    str += l;
-                }
-                Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, buf, len));
-                return JIM_OK;
-            }
-
-        case OPT_INDEX:{
-                int idx;
-                const char *str;
-
-                if (Jim_GetIndex(interp, argv[3], &idx) != JIM_OK) {
-                    return JIM_ERR;
-                }
-                str = Jim_String(argv[2]);
-                len = Jim_Utf8Length(interp, argv[2]);
-                idx = JimRelToAbsIndex(len, idx);
-                if (idx < 0 || idx >= len || str == NULL) {
-                    Jim_SetResultString(interp, "", 0);
-                }
-                else if (len == Jim_Length(argv[2])) {
-
-                    Jim_SetResultString(interp, str + idx, 1);
-                }
-                else {
-                    int c;
-                    int i = utf8_index(str, idx);
-                    Jim_SetResultString(interp, str + i, utf8_tounicode(str + i, &c));
-                }
-                return JIM_OK;
-            }
-
-        case OPT_FIRST:
-        case OPT_LAST:{
-                int idx = 0, l1, l2;
-                const char *s1, *s2;
-
-                s1 = Jim_String(argv[2]);
-                s2 = Jim_String(argv[3]);
-                l1 = Jim_Utf8Length(interp, argv[2]);
-                l2 = Jim_Utf8Length(interp, argv[3]);
-                if (argc == 5) {
-                    if (Jim_GetIndex(interp, argv[4], &idx) != JIM_OK) {
-                        return JIM_ERR;
-                    }
-                    idx = JimRelToAbsIndex(l2, idx);
-                    if (idx < 0) {
-                        idx = 0;
-                    }
-                }
-                else if (option == OPT_LAST) {
-                    idx = l2;
-                }
-                if (option == OPT_FIRST) {
-                    Jim_SetResultInt(interp, JimStringFirst(s1, l1, s2, l2, idx));
-                }
-                else {
-#ifdef JIM_UTF8
-                    Jim_SetResultInt(interp, JimStringLastUtf8(s1, l1, s2, idx));
-#else
-                    Jim_SetResultInt(interp, JimStringLast(s1, l1, s2, idx));
-#endif
-                }
-                return JIM_OK;
-            }
-
-        case OPT_TRIM:
-                Jim_SetResult(interp, JimStringTrim(interp, argv[2], argc == 4 ? argv[3] : NULL));
-                return JIM_OK;
-        case OPT_TRIMLEFT:
-                Jim_SetResult(interp, JimStringTrimLeft(interp, argv[2], argc == 4 ? argv[3] : NULL));
-                return JIM_OK;
-        case OPT_TRIMRIGHT:{
-                Jim_SetResult(interp, JimStringTrimRight(interp, argv[2], argc == 4 ? argv[3] : NULL));
-                return JIM_OK;
-        }
-
-        case OPT_TOLOWER:
-                Jim_SetResult(interp, JimStringToLower(interp, argv[2]));
-                return JIM_OK;
-        case OPT_TOUPPER:
-                Jim_SetResult(interp, JimStringToUpper(interp, argv[2]));
-                return JIM_OK;
-        case OPT_TOTITLE:
-                Jim_SetResult(interp, JimStringToTitle(interp, argv[2]));
-                return JIM_OK;
-
-        case OPT_IS:
-            if (argc == 5 && !Jim_CompareStringImmediate(interp, argv[3], "-strict")) {
-                Jim_SubCmdArgError(interp, ct, argv[0]);
-                return JIM_ERR;
-            }
-            return JimStringIs(interp, argv[argc - 1], argv[2], argc == 5);
-    }
-    return JIM_OK;
-}
-
-
-static int Jim_TimeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    long i, count = 1;
-    jim_wide start, elapsed;
-
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "script ?count?");
-        return JIM_ERR;
-    }
-    if (argc == 3) {
-        if (Jim_GetLong(interp, argv[2], &count) != JIM_OK)
-            return JIM_ERR;
-    }
-    if (count < 0)
-        return JIM_OK;
-    i = count;
-    start = Jim_GetTimeUsec(CLOCK_MONOTONIC_RAW);
-    while (i-- > 0) {
-        int retval;
-
-        retval = Jim_EvalObj(interp, argv[1]);
-        if (retval != JIM_OK) {
-            return retval;
-        }
-    }
-    elapsed = Jim_GetTimeUsec(CLOCK_MONOTONIC_RAW) - start;
-    if (elapsed < count * 10) {
-        Jim_SetResult(interp, Jim_NewDoubleObj(interp, elapsed * 1.0 / count));
-    }
-    else {
-        Jim_SetResultInt(interp, count == 0 ? 0 : elapsed / count);
-    }
-    Jim_AppendString(interp, Jim_GetResult(interp)," microseconds per iteration", -1);
-    return JIM_OK;
-}
-
-
-static int Jim_TimeRateCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    long us = 0;
-    jim_wide start, delta, overhead;
-    Jim_Obj *objPtr;
-    double us_per_iter;
-    int count;
-    int n;
-
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "script ?milliseconds?");
-        return JIM_ERR;
-    }
-    if (argc == 3) {
-        if (Jim_GetLong(interp, argv[2], &us) != JIM_OK)
-            return JIM_ERR;
-        us *= 1000;
-    }
-    if (us < 1) {
-
-        us = 1000 * 1000;
-    }
-
-
-    start = Jim_GetTimeUsec(CLOCK_MONOTONIC_RAW);
-    count = 0;
-    do {
-        int retval = Jim_EvalObj(interp, argv[1]);
-        delta = Jim_GetTimeUsec(CLOCK_MONOTONIC_RAW) - start;
-        if (retval != JIM_OK) {
-            return retval;
-        }
-        count++;
-    } while (delta < us);
-
-
-    start = Jim_GetTimeUsec(CLOCK_MONOTONIC_RAW);
-    n = 0;
-    do {
-        int retval = Jim_EvalObj(interp, interp->nullScriptObj);
-        overhead = Jim_GetTimeUsec(CLOCK_MONOTONIC_RAW) - start;
-        if (retval != JIM_OK) {
-            return retval;
-        }
-        n++;
-    } while (n < count);
-
-    delta -= overhead;
-
-    us_per_iter = (double)delta / count;
-    objPtr = Jim_NewListObj(interp, NULL, 0);
-
-    Jim_ListAppendElement(interp, objPtr, Jim_NewStringObj(interp, "us_per_iter", -1));
-    Jim_ListAppendElement(interp, objPtr, Jim_NewDoubleObj(interp, us_per_iter));
-    Jim_ListAppendElement(interp, objPtr, Jim_NewStringObj(interp, "iters_per_sec", -1));
-    Jim_ListAppendElement(interp, objPtr, Jim_NewDoubleObj(interp, 1e6 / us_per_iter));
-    Jim_ListAppendElement(interp, objPtr, Jim_NewStringObj(interp, "count", -1));
-    Jim_ListAppendElement(interp, objPtr, Jim_NewIntObj(interp, count));
-    Jim_ListAppendElement(interp, objPtr, Jim_NewStringObj(interp, "elapsed_us", -1));
-    Jim_ListAppendElement(interp, objPtr, Jim_NewIntObj(interp, delta));
-    Jim_SetResult(interp, objPtr);
-    return JIM_OK;
-}
-
-
-static int Jim_ExitCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    long exitCode = 0;
-
-    if (argc > 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "?exitCode?");
-        return JIM_ERR;
-    }
-    if (argc == 2) {
-        if (Jim_GetLong(interp, argv[1], &exitCode) != JIM_OK)
-            return JIM_ERR;
-        Jim_SetResult(interp, argv[1]);
-    }
-    interp->exitCode = exitCode;
-    return JIM_EXIT;
-}
-
-static int JimMatchReturnCodes(Jim_Interp *interp, Jim_Obj *retcodeListObj, int rc)
-{
-    int len = Jim_ListLength(interp, retcodeListObj);
-    int i;
-    for (i = 0; i < len; i++) {
-        int returncode;
-        if (Jim_GetReturnCode(interp, Jim_ListGetIndex(interp, retcodeListObj, i), &returncode) != JIM_OK) {
-            return JIM_ERR;
-        }
-        if (rc == returncode) {
-            return JIM_OK;
-        }
-    }
-    return -1;
-}
-
-
-static int JimCatchTryHelper(Jim_Interp *interp, int istry, int argc, Jim_Obj *const *argv)
-{
-    static const char * const wrongargs_catchtry[2] = {
-        "?-?no?code ... --? script ?resultVarName? ?optionVarName?",
-        "?-?no?code ... --? script ?on|trap codes vars script? ... ?finally script?"
-    };
-    int exitCode = 0;
-    int i;
-    int sig = 0;
-    int ok;
-    Jim_Obj *finallyScriptObj = NULL;
-    Jim_Obj *msgVarObj = NULL;
-    Jim_Obj *optsVarObj = NULL;
-    Jim_Obj *handlerScriptObj = NULL;
-    Jim_Obj *errorCodeObj;
-    int idx;
-
-
-    jim_wide ignore_mask = (1 << JIM_EXIT) | (1 << JIM_EVAL) | (1 << JIM_SIGNAL);
-    static const int max_ignore_code = sizeof(ignore_mask) * 8;
-
-    JimPanic((istry != 0 && istry != 1, "wrong args to JimCatchTryHelper"));
-
-    Jim_SetGlobalVariableStr(interp, "errorCode", Jim_NewStringObj(interp, "NONE", -1));
-
-    for (i = 1; i < argc - 1; i++) {
-        const char *arg = Jim_String(argv[i]);
-        jim_wide option;
-        int ignore;
-
-
-        if (strcmp(arg, "--") == 0) {
-            i++;
-            break;
-        }
-        if (*arg != '-') {
-            break;
-        }
-
-        if (strncmp(arg, "-no", 3) == 0) {
-            arg += 3;
-            ignore = 1;
-        }
-        else {
-            arg++;
-            ignore = 0;
-        }
-
-        if (Jim_StringToWide(arg, &option, 10) != JIM_OK) {
-            option = -1;
-        }
-        if (option < 0) {
-            option = Jim_FindByName(arg, jimReturnCodes, jimReturnCodesSize);
-        }
-        if (option < 0) {
-            goto wrongargs;
-        }
-
-        if (ignore) {
-            ignore_mask |= ((jim_wide)1 << option);
-        }
-        else {
-            ignore_mask &= (~((jim_wide)1 << option));
-        }
-    }
-
-    idx = i;
-
-    if (argc - idx < 1) {
-wrongargs:
-        Jim_WrongNumArgs(interp, 1, argv, wrongargs_catchtry[istry]);
-        return JIM_ERR;
-    }
-
-    if ((ignore_mask & (1 << JIM_SIGNAL)) == 0) {
-        sig++;
-    }
-
-    interp->signal_level += sig;
-    if (Jim_CheckSignal(interp)) {
-
-        exitCode = JIM_SIGNAL;
-    }
-    else {
-        exitCode = Jim_EvalObj(interp, argv[idx]);
-
-        interp->errorFlag = 0;
-    }
-    interp->signal_level -= sig;
-
-    errorCodeObj = Jim_GetGlobalVariableStr(interp, "errorCode", JIM_NONE);
-
-    idx++;
-    if (istry) {
-        while (idx < argc) {
-            int option;
-            int ret;
-            static const char * const try_options[] = { "on", "trap", "finally", NULL };
-            enum { TRY_ON, TRY_TRAP, TRY_FINALLY, };
-
-            if (Jim_GetEnum(interp, argv[idx], try_options, &option, "handler", JIM_ERRMSG) != JIM_OK) {
-                return JIM_ERR;
-            }
-            switch (option) {
-                case TRY_ON:
-                case TRY_TRAP:
-                    if (idx + 4 > argc) {
-                        goto wrongargs;
-                    }
-                    if (option == TRY_ON) {
-                        ret = JimMatchReturnCodes(interp, argv[idx + 1], exitCode);
-                        if (ret > JIM_OK) {
-                            goto wrongargs;
-                        }
-                    }
-                    else if (errorCodeObj) {
-                        int len = Jim_ListLength(interp, argv[idx + 1]);
-                        int i;
-
-                        ret = JIM_OK;
-
-                        for (i = 0; i < len; i++) {
-                            Jim_Obj *matchObj = Jim_ListGetIndex(interp, argv[idx + 1], i);
-                            Jim_Obj *objPtr = Jim_ListGetIndex(interp, errorCodeObj, i);
-                            if (Jim_StringCompareObj(interp, matchObj, objPtr, 0) != 0) {
-                                ret = -1;
-                                break;
-                            }
-                        }
-                    }
-                    else {
-
-                        ret = -1;
-                    }
-
-                    if (ret == JIM_OK && handlerScriptObj == NULL) {
-                        msgVarObj = Jim_ListGetIndex(interp, argv[idx + 2], 0);
-                        optsVarObj = Jim_ListGetIndex(interp, argv[idx + 2], 1);
-                        handlerScriptObj = argv[idx + 3];
-                    }
-                    idx += 4;
-                    break;
-                case TRY_FINALLY:
-                    if (idx + 2 != argc) {
-                        goto wrongargs;
-                    }
-                    finallyScriptObj = argv[idx + 1];
-                    idx += 2;
-                    break;
-            }
-        }
-    }
-    else {
-        if (argc - idx >= 1) {
-            msgVarObj = argv[idx];
-            idx++;
-            if (argc - idx >= 1) {
-                optsVarObj = argv[idx];
-                idx++;
-            }
-        }
-    }
-
-
-    if (exitCode >= 0 && exitCode < max_ignore_code && (((unsigned jim_wide)1 << exitCode) & ignore_mask)) {
-
-        if (finallyScriptObj) {
-            Jim_EvalObj(interp, finallyScriptObj);
-        }
-        return exitCode;
-    }
-
-    if (sig && exitCode == JIM_SIGNAL) {
-
-        if (interp->signal_set_result) {
-            interp->signal_set_result(interp, interp->sigmask);
-        }
-        else if (!istry) {
-            Jim_SetResultInt(interp, interp->sigmask);
-        }
-        interp->sigmask = 0;
-    }
-
-    ok = 1;
-    if (msgVarObj && Jim_Length(msgVarObj)) {
-        if (Jim_SetVariable(interp, msgVarObj, Jim_GetResult(interp)) != JIM_OK) {
-            ok = 0;
-        }
-    }
-    if (ok && optsVarObj && Jim_Length(optsVarObj)) {
-        Jim_Obj *optListObj = Jim_NewListObj(interp, NULL, 0);
-
-        Jim_ListAppendElement(interp, optListObj, Jim_NewStringObj(interp, "-code", -1));
-        Jim_ListAppendElement(interp, optListObj,
-            Jim_NewIntObj(interp, exitCode == JIM_RETURN ? interp->returnCode : exitCode));
-        Jim_ListAppendElement(interp, optListObj, Jim_NewStringObj(interp, "-level", -1));
-        Jim_ListAppendElement(interp, optListObj, Jim_NewIntObj(interp, interp->returnLevel));
-        if (exitCode == JIM_ERR) {
-            Jim_ListAppendElement(interp, optListObj, Jim_NewStringObj(interp, "-errorinfo",
-                -1));
-            Jim_ListAppendElement(interp, optListObj, interp->stackTrace);
-
-            if (errorCodeObj) {
-                Jim_ListAppendElement(interp, optListObj, Jim_NewStringObj(interp, "-errorcode", -1));
-                Jim_ListAppendElement(interp, optListObj, errorCodeObj);
-            }
-        }
-        if (Jim_SetVariable(interp, optsVarObj, optListObj) != JIM_OK) {
-            ok = 0;
-        }
-    }
-    if (ok && handlerScriptObj) {
-
-        exitCode = Jim_EvalObj(interp, handlerScriptObj);
-    }
-
-    if (finallyScriptObj) {
-
-        Jim_Obj *prevResultObj = Jim_GetResult(interp);
-        Jim_IncrRefCount(prevResultObj);
-        int ret = Jim_EvalObj(interp, finallyScriptObj);
-        if (ret == JIM_OK) {
-            Jim_SetResult(interp, prevResultObj);
-        }
-        else {
-            exitCode = ret;
-        }
-        Jim_DecrRefCount(interp, prevResultObj);
-    }
-    if (!istry) {
-        Jim_SetResultInt(interp, exitCode);
-        exitCode = JIM_OK;
-    }
-    return exitCode;
-}
-
-
-static int Jim_CatchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return JimCatchTryHelper(interp, 0, argc, argv);
-}
-
-
-static int Jim_TryCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    return JimCatchTryHelper(interp, 1, argc, argv);
-}
-
-
-
-static int Jim_RenameCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    if (argc != 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "oldName newName");
-        return JIM_ERR;
-    }
-
-    return Jim_RenameCommand(interp, argv[1], argv[2]);
-}
-
-#define JIM_DICTMATCH_KEYS 0x0001
-#define JIM_DICTMATCH_VALUES 0x002
-
-int Jim_DictMatchTypes(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *patternObj, int match_type, int return_types)
-{
-    Jim_Obj *listObjPtr;
-    Jim_Dict *dict;
-    int i;
-
-    if (SetDictFromAny(interp, objPtr) != JIM_OK) {
-        return JIM_ERR;
-    }
-    dict = objPtr->internalRep.dictValue;
-
-    listObjPtr = Jim_NewListObj(interp, NULL, 0);
-
-    for (i = 0; i < dict->len; i += 2 ) {
-        Jim_Obj *keyObj = dict->table[i];
-        Jim_Obj *valObj = dict->table[i + 1];
-        if (patternObj) {
-            Jim_Obj *matchObj = (match_type == JIM_DICTMATCH_KEYS) ? keyObj : valObj;
-            if (!Jim_StringMatchObj(interp, patternObj, matchObj, 0)) {
-
-                continue;
-            }
-        }
-        if (return_types & JIM_DICTMATCH_KEYS) {
-            Jim_ListAppendElement(interp, listObjPtr, keyObj);
-        }
-        if (return_types & JIM_DICTMATCH_VALUES) {
-            Jim_ListAppendElement(interp, listObjPtr, valObj);
-        }
-    }
-
-    Jim_SetResult(interp, listObjPtr);
-    return JIM_OK;
-}
-
-int Jim_DictSize(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    if (SetDictFromAny(interp, objPtr) != JIM_OK) {
-        return -1;
-    }
-    return objPtr->internalRep.dictValue->len / 2;
-}
-
-Jim_Obj *Jim_DictMerge(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
-{
-    Jim_Obj *objPtr = Jim_NewDictObj(interp, NULL, 0);
-    int i;
-
-    JimPanic((objc == 0, "Jim_DictMerge called with objc=0"));
-
-
-
-    for (i = 0; i < objc; i++) {
-        Jim_Obj **table;
-        int tablelen;
-        int j;
-
-        table = Jim_DictPairs(interp, objv[i], &tablelen);
-        if (tablelen && !table) {
-            Jim_FreeNewObj(interp, objPtr);
-            return NULL;
-        }
-        for (j = 0; j < tablelen; j += 2) {
-            DictAddElement(interp, objPtr, table[j], table[j + 1]);
-        }
-    }
-    return objPtr;
-}
-
-int Jim_DictInfo(Jim_Interp *interp, Jim_Obj *objPtr)
-{
-    char buffer[100];
-    Jim_Obj *output;
-    Jim_Dict *dict;
-
-    if (SetDictFromAny(interp, objPtr) != JIM_OK) {
-        return JIM_ERR;
-    }
-
-    dict = objPtr->internalRep.dictValue;
-
-
-    snprintf(buffer, sizeof(buffer), "%d entries in table, %d buckets", dict->len, dict->size);
-    output = Jim_NewStringObj(interp, buffer, -1);
-    Jim_SetResult(interp, output);
-    return JIM_OK;
-}
-
-static int Jim_EvalEnsemble(Jim_Interp *interp, const char *basecmd, const char *subcmd, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *prefixObj = Jim_NewStringObj(interp, basecmd, -1);
-
-    Jim_AppendString(interp, prefixObj, " ", 1);
-    Jim_AppendString(interp, prefixObj, subcmd, -1);
-
-    return Jim_EvalObjPrefix(interp, prefixObj, argc, argv);
-}
-
-static int JimDictWith(Jim_Interp *interp, Jim_Obj *dictVarName, Jim_Obj *const *keyv, int keyc, Jim_Obj *scriptObj)
-{
-    int i;
-    Jim_Obj *objPtr;
-    Jim_Obj *dictObj;
-    Jim_Obj **dictValues;
-    int len;
-    int ret = JIM_OK;
-
-
-    dictObj = Jim_GetVariable(interp, dictVarName, JIM_ERRMSG);
-    if (dictObj == NULL || Jim_DictKeysVector(interp, dictObj, keyv, keyc, &objPtr, JIM_ERRMSG) != JIM_OK) {
-        return JIM_ERR;
-    }
-
-    dictValues = Jim_DictPairs(interp, objPtr, &len);
-    if (len && dictValues == NULL) {
-        return JIM_ERR;
-    }
-    for (i = 0; i < len; i += 2) {
-        if (Jim_SetVariable(interp, dictValues[i], dictValues[i + 1]) == JIM_ERR) {
-            return JIM_ERR;
-        }
-    }
-
-
-    if (Jim_Length(scriptObj)) {
-        ret = Jim_EvalObj(interp, scriptObj);
-
-
-        if (ret == JIM_OK && Jim_GetVariable(interp, dictVarName, 0) != NULL) {
-
-            Jim_Obj **newkeyv = Jim_Alloc(sizeof(*newkeyv) * (keyc + 1));
-            for (i = 0; i < keyc; i++) {
-                newkeyv[i] = keyv[i];
-            }
-
-            for (i = 0; i < len; i += 2) {
-
-                if (Jim_StringCompareObj(interp, dictVarName, dictValues[i], 0) != 0) {
-
-                    objPtr = Jim_GetVariable(interp, dictValues[i], 0);
-                    newkeyv[keyc] = dictValues[i];
-                    Jim_SetDictKeysVector(interp, dictVarName, newkeyv, keyc + 1, objPtr, JIM_NORESULT);
-                }
-            }
-            Jim_Free(newkeyv);
-        }
-    }
-
-    return ret;
-}
-
-
-static int Jim_DictCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *objPtr;
-    int types = JIM_DICTMATCH_KEYS;
-
-    enum {
-        OPT_CREATE,
-        OPT_GET,
-        OPT_GETDEF,
-        OPT_GETWITHDEFAULT,
-        OPT_SET,
-        OPT_UNSET,
-        OPT_EXISTS,
-        OPT_KEYS,
-        OPT_SIZE,
-        OPT_INFO,
-        OPT_MERGE,
-        OPT_WITH,
-        OPT_APPEND,
-        OPT_LAPPEND,
-        OPT_INCR,
-        OPT_REMOVE,
-        OPT_VALUES,
-        OPT_FOR,
-        OPT_REPLACE,
-        OPT_UPDATE,
-        OPT_COUNT
-    };
-    static const jim_subcmd_type cmds[OPT_COUNT + 1] = {
-        JIM_DEF_SUBCMD("create", "?key value ...?", 0, -2),
-        JIM_DEF_SUBCMD("get", "dictionary ?key ...?", 1, -1),
-        JIM_DEF_SUBCMD_HIDDEN("getdef", "dictionary ?key ...? key default", 3, -1),
-        JIM_DEF_SUBCMD("getwithdefault", "dictionary ?key ...? key default", 3, -1),
-        JIM_DEF_SUBCMD("set", "varName key ?key ...? value", 3, -1),
-        JIM_DEF_SUBCMD("unset", "varName key ?key ...?", 2, -1),
-        JIM_DEF_SUBCMD("exists", "dictionary key ?key ...?", 2, -1),
-        JIM_DEF_SUBCMD("keys", "dictionary ?pattern?", 1, 2),
-        JIM_DEF_SUBCMD("size", "dictionary", 1, 1),
-        JIM_DEF_SUBCMD("info", "dictionary", 1, 1),
-        JIM_DEF_SUBCMD("merge", "?...?", 0, -1),
-        JIM_DEF_SUBCMD("with", "dictVar ?key ...? script", 2, -1),
-        JIM_DEF_SUBCMD("append", "varName key ?value ...?", 2, -1),
-        JIM_DEF_SUBCMD("lappend",  "varName key ?value ...?", 2, -1),
-        JIM_DEF_SUBCMD("incr", "varName key ?increment?", 2, 3),
-        JIM_DEF_SUBCMD("remove", "dictionary ?key ...?", 1, -1),
-        JIM_DEF_SUBCMD("values", "dictionary ?pattern?", 1, 2),
-        JIM_DEF_SUBCMD("for", "vars dictionary script", 3, 3),
-        JIM_DEF_SUBCMD("replace", "dictionary ?key value ...?", 1, -1),
-        JIM_DEF_SUBCMD("update", "varName ?arg ...? script", 2, -1),
-        { NULL }
-    };
-    const jim_subcmd_type *ct = Jim_ParseSubCmd(interp, cmds, argc, argv);
-    if (!ct) {
-        return JIM_ERR;
-    }
-    if (ct->function) {
-
-        return ct->function(interp, argc, argv);
-    }
-
-
-    switch (ct - cmds) {
-        case OPT_GET:
-            if (Jim_DictKeysVector(interp, argv[2], argv + 3, argc - 3, &objPtr,
-                    JIM_ERRMSG) != JIM_OK) {
-                return JIM_ERR;
-            }
-            Jim_SetResult(interp, objPtr);
-            return JIM_OK;
-
-        case OPT_GETDEF:
-        case OPT_GETWITHDEFAULT:{
-            int rc = Jim_DictKeysVector(interp, argv[2], argv + 3, argc - 4, &objPtr, JIM_ERRMSG);
-            if (rc == -1) {
-
-                return JIM_ERR;
-            }
-            if (rc == JIM_ERR) {
-                Jim_SetResult(interp, argv[argc - 1]);
-            }
-            else {
-                Jim_SetResult(interp, objPtr);
-            }
-            return JIM_OK;
-        }
-
-        case OPT_SET:
-            return Jim_SetDictKeysVector(interp, argv[2], argv + 3, argc - 4, argv[argc - 1], JIM_ERRMSG);
-
-        case OPT_EXISTS:{
-                int rc = Jim_DictKeysVector(interp, argv[2], argv + 3, argc - 3, &objPtr, JIM_NONE);
-                if (rc < 0) {
-                    return JIM_ERR;
-                }
-                Jim_SetResultBool(interp,  rc == JIM_OK);
-                return JIM_OK;
-            }
-
-        case OPT_UNSET:
-            if (Jim_SetDictKeysVector(interp, argv[2], argv + 3, argc - 3, NULL, JIM_NONE) != JIM_OK) {
-                return JIM_ERR;
-            }
-            return JIM_OK;
-
-        case OPT_VALUES:
-            types = JIM_DICTMATCH_VALUES;
-
-        case OPT_KEYS:
-            return Jim_DictMatchTypes(interp, argv[2], argc == 4 ? argv[3] : NULL, types, types);
-
-        case OPT_SIZE:
-            if (Jim_DictSize(interp, argv[2]) < 0) {
-                return JIM_ERR;
-            }
-            Jim_SetResultInt(interp, Jim_DictSize(interp, argv[2]));
-            return JIM_OK;
-
-        case OPT_MERGE:
-            if (argc == 2) {
-                return JIM_OK;
-            }
-            objPtr = Jim_DictMerge(interp, argc - 2, argv + 2);
-            if (objPtr == NULL) {
-                return JIM_ERR;
-            }
-            Jim_SetResult(interp, objPtr);
-            return JIM_OK;
-
-        case OPT_CREATE:
-            objPtr = Jim_NewDictObj(interp, argv + 2, argc - 2);
-            Jim_SetResult(interp, objPtr);
-            return JIM_OK;
-
-        case OPT_INFO:
-            return Jim_DictInfo(interp, argv[2]);
-
-        case OPT_WITH:
-            return JimDictWith(interp, argv[2], argv + 3, argc - 4, argv[argc - 1]);
-
-        case OPT_UPDATE:
-            if (argc < 6 || argc % 2) {
-
-                argc = 2;
-            }
-
-        default:
-            return Jim_EvalEnsemble(interp, "dict", Jim_String(argv[1]), argc - 2, argv + 2);
-    }
-}
-
-
-static int Jim_SubstCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    static const char * const options[] = {
-        "-nobackslashes", "-nocommands", "-novariables", NULL
-    };
-    enum
-    { OPT_NOBACKSLASHES, OPT_NOCOMMANDS, OPT_NOVARIABLES };
-    int i;
-    int flags = JIM_SUBST_FLAG;
-    Jim_Obj *objPtr;
-
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "?options? string");
-        return JIM_ERR;
-    }
-    for (i = 1; i < (argc - 1); i++) {
-        int option;
-
-        if (Jim_GetEnum(interp, argv[i], options, &option, NULL,
-                JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK) {
-            return JIM_ERR;
-        }
-        switch (option) {
-            case OPT_NOBACKSLASHES:
-                flags |= JIM_SUBST_NOESC;
-                break;
-            case OPT_NOCOMMANDS:
-                flags |= JIM_SUBST_NOCMD;
-                break;
-            case OPT_NOVARIABLES:
-                flags |= JIM_SUBST_NOVAR;
-                break;
-        }
-    }
-    if (Jim_SubstObj(interp, argv[argc - 1], &objPtr, flags) != JIM_OK) {
-        return JIM_ERR;
-    }
-    Jim_SetResult(interp, objPtr);
-    return JIM_OK;
-}
-
-#ifdef jim_ext_namespace
-static int JimIsGlobalNamespace(Jim_Obj *objPtr)
-{
-    int len;
-    const char *str = Jim_GetString(objPtr, &len);
-    return len >= 2 && str[0] == ':' && str[1] == ':';
-}
-#endif
-
-
-static int Jim_InfoCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *objPtr;
-    int mode = 0;
-
-
-    enum {
-        INFO_ALIAS,
-        INFO_ARGS,
-        INFO_BODY,
-        INFO_CHANNELS,
-        INFO_COMMANDS,
-        INFO_COMPLETE,
-        INFO_EXISTS,
-        INFO_FRAME,
-        INFO_GLOBALS,
-        INFO_HOSTNAME,
-        INFO_LEVEL,
-        INFO_LOCALS,
-        INFO_NAMEOFEXECUTABLE,
-        INFO_PATCHLEVEL,
-        INFO_PROCS,
-        INFO_REFERENCES,
-        INFO_RETURNCODES,
-        INFO_SCRIPT,
-        INFO_SOURCE,
-        INFO_STACKTRACE,
-        INFO_STATICS,
-        INFO_VARS,
-        INFO_VERSION,
-        INFO_COUNT
-    };
-    static const jim_subcmd_type cmds[INFO_COUNT + 1] = {
-        JIM_DEF_SUBCMD("alias", "command", 1, 1),
-        JIM_DEF_SUBCMD("args", "procname", 1, 1),
-        JIM_DEF_SUBCMD("body", "procname", 1, 1),
-        JIM_DEF_SUBCMD("channels", "?pattern?", 0, 1),
-        JIM_DEF_SUBCMD("commands", "?pattern?", 0, 1),
-        JIM_DEF_SUBCMD("complete", "script ?missing?", 1, 2),
-        JIM_DEF_SUBCMD("exists", "varName", 1, 1),
-        JIM_DEF_SUBCMD("frame", "?levelNum?", 0, 1),
-        JIM_DEF_SUBCMD("globals", "?pattern?", 0, 1),
-        JIM_DEF_SUBCMD("hostname", NULL, 0, 0),
-        JIM_DEF_SUBCMD("level", "?levelNum?", 0, 1),
-        JIM_DEF_SUBCMD("locals", "?pattern?", 0, 1),
-        JIM_DEF_SUBCMD("nameofexecutable", NULL, 0, 0),
-        JIM_DEF_SUBCMD("patchlevel", NULL, 0, 0),
-        JIM_DEF_SUBCMD("procs", "?pattern?", 0, 1),
-        JIM_DEF_SUBCMD("references", NULL, 0, 0),
-        JIM_DEF_SUBCMD("returncodes", "?code?", 0, 1),
-        JIM_DEF_SUBCMD("script", "?filename?", 0, 1),
-        JIM_DEF_SUBCMD("source", "source ?filename line?", 1, 3),
-        JIM_DEF_SUBCMD("stacktrace", NULL, 0, 0),
-        JIM_DEF_SUBCMD("statics", "procname", 1, 1),
-        JIM_DEF_SUBCMD("vars", "?pattern?", 0, 1),
-        JIM_DEF_SUBCMD("version", NULL, 0, 0),
-        { NULL }
-    };
-    const jim_subcmd_type *ct;
-#ifdef jim_ext_namespace
-    int nons = 0;
-
-    if (argc > 2 && Jim_CompareStringImmediate(interp, argv[1], "-nons")) {
-
-        argc--;
-        argv++;
-        nons = 1;
-    }
-#endif
-    ct = Jim_ParseSubCmd(interp, cmds, argc, argv);
-    if (!ct) {
-        return JIM_ERR;
-    }
-    if (ct->function) {
-
-        return ct->function(interp, argc, argv);
-    }
-
-    int option = ct - cmds;
-
-    switch (option) {
-        case INFO_EXISTS:
-            Jim_SetResultBool(interp, Jim_GetVariable(interp, argv[2], 0) != NULL);
-            return JIM_OK;
-
-        case INFO_ALIAS:{
-            Jim_Cmd *cmdPtr;
-
-            if ((cmdPtr = Jim_GetCommand(interp, argv[2], JIM_ERRMSG)) == NULL) {
-                return JIM_ERR;
-            }
-            if (cmdPtr->isproc || cmdPtr->u.native.cmdProc != JimAliasCmd) {
-                Jim_SetResultFormatted(interp, "command \"%#s\" is not an alias", argv[2]);
-                return JIM_ERR;
-            }
-            Jim_SetResult(interp, (Jim_Obj *)cmdPtr->u.native.privData);
-            return JIM_OK;
-        }
-
-        case INFO_CHANNELS:
-            mode++;
-#ifndef jim_ext_aio
-            Jim_SetResultString(interp, "aio not enabled", -1);
-            return JIM_ERR;
-#endif
-
-        case INFO_PROCS:
-            mode++;
-
-        case INFO_COMMANDS:
-
-#ifdef jim_ext_namespace
-            if (!nons) {
-                if (Jim_Length(interp->framePtr->nsObj) || (argc == 3 && JimIsGlobalNamespace(argv[2]))) {
-                    return Jim_EvalPrefix(interp, "namespace info", argc - 1, argv + 1);
-                }
-            }
-#endif
-            Jim_SetResult(interp, JimCommandsList(interp, (argc == 3) ? argv[2] : NULL, mode));
-            return JIM_OK;
-
-        case INFO_VARS:
-            mode++;
-
-        case INFO_LOCALS:
-            mode++;
-
-        case INFO_GLOBALS:
-
-#ifdef jim_ext_namespace
-            if (!nons) {
-                if (Jim_Length(interp->framePtr->nsObj) || (argc == 3 && JimIsGlobalNamespace(argv[2]))) {
-                    return Jim_EvalPrefix(interp, "namespace info", argc - 1, argv + 1);
-                }
-            }
-#endif
-            Jim_SetResult(interp, JimVariablesList(interp, argc == 3 ? argv[2] : NULL, mode));
-            return JIM_OK;
-
-        case INFO_SCRIPT:
-            if (argc == 3) {
-                Jim_IncrRefCount(argv[2]);
-                Jim_DecrRefCount(interp, interp->currentFilenameObj);
-                interp->currentFilenameObj = argv[2];
-            }
-            Jim_SetResult(interp, interp->currentFilenameObj);
-            return JIM_OK;
-
-        case INFO_SOURCE:{
-                Jim_Obj *resObjPtr;
-                Jim_Obj *fileNameObj;
-
-                if (argc == 4) {
-                    Jim_SubCmdArgError(interp, ct, argv[0]);
-                    return JIM_ERR;
-                }
-                if (argc == 5) {
-                    jim_wide line;
-                    if (Jim_GetWide(interp, argv[4], &line) != JIM_OK) {
-                        return JIM_ERR;
-                    }
-                    resObjPtr = Jim_NewStringObj(interp, Jim_String(argv[2]), Jim_Length(argv[2]));
-                    Jim_SetSourceInfo(interp, resObjPtr, argv[3], line);
-                }
-                else {
-                    int line;
-                    fileNameObj = Jim_GetSourceInfo(interp, argv[2], &line);
-                    resObjPtr = Jim_NewListObj(interp, NULL, 0);
-                    Jim_ListAppendElement(interp, resObjPtr, fileNameObj);
-                    Jim_ListAppendElement(interp, resObjPtr, Jim_NewIntObj(interp, line));
-                }
-                Jim_SetResult(interp, resObjPtr);
-                return JIM_OK;
-            }
-
-        case INFO_STACKTRACE:
-            Jim_SetResult(interp, interp->stackTrace);
-            return JIM_OK;
-
-        case INFO_LEVEL:
-            if (argc == 2) {
-                Jim_SetResultInt(interp, interp->framePtr->level);
-            }
-            else {
-                if (JimInfoLevel(interp, argv[2], &objPtr) != JIM_OK) {
-                    return JIM_ERR;
-                }
-                Jim_SetResult(interp, objPtr);
-            }
-            return JIM_OK;
-
-        case INFO_FRAME:
-            if (argc == 2) {
-                Jim_SetResultInt(interp, interp->procLevel + 1);
-            }
-            else {
-                if (JimInfoFrame(interp, argv[2], &objPtr) != JIM_OK) {
-                    return JIM_ERR;
-                }
-                Jim_SetResult(interp, objPtr);
-            }
-            return JIM_OK;
-
-        case INFO_BODY:
-        case INFO_STATICS:
-        case INFO_ARGS:{
-                Jim_Cmd *cmdPtr;
-
-                if ((cmdPtr = Jim_GetCommand(interp, argv[2], JIM_ERRMSG)) == NULL) {
-                    return JIM_ERR;
-                }
-                if (!cmdPtr->isproc) {
-                    Jim_SetResultFormatted(interp, "command \"%#s\" is not a procedure", argv[2]);
-                    return JIM_ERR;
-                }
-                switch (option) {
-#ifdef JIM_NO_INTROSPECTION
-                    default:
-                        Jim_SetResultString(interp, "unsupported", -1);
-                        return JIM_ERR;
-#else
-                    case INFO_BODY:
-                        Jim_SetResult(interp, cmdPtr->u.proc.bodyObjPtr);
-                        break;
-                    case INFO_ARGS:
-                        Jim_SetResult(interp, cmdPtr->u.proc.argListObjPtr);
-                        break;
-#endif
-                    case INFO_STATICS:
-                        if (cmdPtr->u.proc.staticVars) {
-                            Jim_SetResult(interp, JimHashtablePatternMatch(interp, cmdPtr->u.proc.staticVars,
-                                NULL, JimVariablesMatch, JIM_VARLIST_LOCALS | JIM_VARLIST_VALUES));
-                        }
-                        break;
-                }
-                return JIM_OK;
-            }
-
-        case INFO_VERSION:
-        case INFO_PATCHLEVEL:{
-                char buf[(JIM_INTEGER_SPACE * 2) + 1];
-
-                sprintf(buf, "%d.%d", JIM_VERSION / 100, JIM_VERSION % 100);
-                Jim_SetResultString(interp, buf, -1);
-                return JIM_OK;
-            }
-
-        case INFO_COMPLETE: {
-                char missing;
-
-                Jim_SetResultBool(interp, Jim_ScriptIsComplete(interp, argv[2], &missing));
-                if (missing != ' ' && argc == 4) {
-                    Jim_SetVariable(interp, argv[3], Jim_NewStringObj(interp, &missing, 1));
-                }
-                return JIM_OK;
-            }
-
-        case INFO_HOSTNAME:
-
-            return Jim_Eval(interp, "os.gethostname");
-
-        case INFO_NAMEOFEXECUTABLE:
-
-            return Jim_Eval(interp, "{info nameofexecutable}");
-
-        case INFO_RETURNCODES:
-            if (argc == 2) {
-                int i;
-                Jim_Obj *listObjPtr = Jim_NewListObj(interp, NULL, 0);
-
-                for (i = 0; jimReturnCodes[i]; i++) {
-                    Jim_ListAppendElement(interp, listObjPtr, Jim_NewIntObj(interp, i));
-                    Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp,
-                            jimReturnCodes[i], -1));
-                }
-
-                Jim_SetResult(interp, listObjPtr);
-            }
-            else if (argc == 3) {
-                long code;
-                const char *name;
-
-                if (Jim_GetLong(interp, argv[2], &code) != JIM_OK) {
-                    return JIM_ERR;
-                }
-                name = Jim_ReturnCode(code);
-                if (*name == '?') {
-                    Jim_SetResultInt(interp, code);
-                }
-                else {
-                    Jim_SetResultString(interp, name, -1);
-                }
-            }
-            return JIM_OK;
-        case INFO_REFERENCES:
-#ifdef JIM_REFERENCES
-            return JimInfoReferences(interp, argc, argv);
-#else
-            Jim_SetResultString(interp, "not supported", -1);
-            return JIM_ERR;
-#endif
-        default:
-            abort();
-    }
-}
-
-
-static int Jim_ExistsCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *objPtr;
-    int result = 0;
-
-    static const char * const options[] = {
-        "-command", "-proc", "-alias", "-var", NULL
-    };
-    enum
-    {
-        OPT_COMMAND, OPT_PROC, OPT_ALIAS, OPT_VAR
-    };
-    int option;
-
-    if (argc == 2) {
-        option = OPT_VAR;
-        objPtr = argv[1];
-    }
-    else if (argc == 3) {
-        if (Jim_GetEnum(interp, argv[1], options, &option, NULL, JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK) {
-            return JIM_ERR;
-        }
-        objPtr = argv[2];
-    }
-    else {
-        Jim_WrongNumArgs(interp, 1, argv, "?option? name");
-        return JIM_ERR;
-    }
-
-    if (option == OPT_VAR) {
-        result = Jim_GetVariable(interp, objPtr, 0) != NULL;
-    }
-    else {
-
-        Jim_Cmd *cmd = Jim_GetCommand(interp, objPtr, JIM_NONE);
-
-        if (cmd) {
-            switch (option) {
-            case OPT_COMMAND:
-                result = 1;
-                break;
-
-            case OPT_ALIAS:
-                result = cmd->isproc == 0 && cmd->u.native.cmdProc == JimAliasCmd;
-                break;
-
-            case OPT_PROC:
-                result = cmd->isproc;
-                break;
-            }
-        }
-    }
-    Jim_SetResultBool(interp, result);
-    return JIM_OK;
-}
-
-
-static int Jim_SplitCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    const char *str, *splitChars, *noMatchStart;
-    int splitLen, strLen;
-    Jim_Obj *resObjPtr;
-    int c;
-    int len;
-
-    if (argc != 2 && argc != 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "string ?splitChars?");
-        return JIM_ERR;
-    }
-
-    str = Jim_GetString(argv[1], &len);
-    if (len == 0) {
-        return JIM_OK;
-    }
-    strLen = Jim_Utf8Length(interp, argv[1]);
-
-
-    if (argc == 2) {
-        splitChars = " \n\t\r";
-        splitLen = 4;
-    }
-    else {
-        splitChars = Jim_String(argv[2]);
-        splitLen = Jim_Utf8Length(interp, argv[2]);
-    }
-
-    noMatchStart = str;
-    resObjPtr = Jim_NewListObj(interp, NULL, 0);
-
-
-    if (splitLen) {
-        Jim_Obj *objPtr;
-        while (strLen--) {
-            const char *sc = splitChars;
-            int scLen = splitLen;
-            int sl = utf8_tounicode(str, &c);
-            while (scLen--) {
-                int pc;
-                sc += utf8_tounicode(sc, &pc);
-                if (c == pc) {
-                    objPtr = Jim_NewStringObj(interp, noMatchStart, (str - noMatchStart));
-                    Jim_ListAppendElement(interp, resObjPtr, objPtr);
-                    noMatchStart = str + sl;
-                    break;
-                }
-            }
-            str += sl;
-        }
-        objPtr = Jim_NewStringObj(interp, noMatchStart, (str - noMatchStart));
-        Jim_ListAppendElement(interp, resObjPtr, objPtr);
-    }
-    else {
-        Jim_Obj **commonObj = NULL;
-#define NUM_COMMON (128 - 9)
-        while (strLen--) {
-            int n = utf8_tounicode(str, &c);
-#ifdef JIM_OPTIMIZATION
-            if (c >= 9 && c < 128) {
-
-                c -= 9;
-                if (!commonObj) {
-                    commonObj = Jim_Alloc(sizeof(*commonObj) * NUM_COMMON);
-                    memset(commonObj, 0, sizeof(*commonObj) * NUM_COMMON);
-                }
-                if (!commonObj[c]) {
-                    commonObj[c] = Jim_NewStringObj(interp, str, 1);
-                }
-                Jim_ListAppendElement(interp, resObjPtr, commonObj[c]);
-                str++;
-                continue;
-            }
-#endif
-            Jim_ListAppendElement(interp, resObjPtr, Jim_NewStringObjUtf8(interp, str, 1));
-            str += n;
-        }
-        Jim_Free(commonObj);
-    }
-
-    Jim_SetResult(interp, resObjPtr);
-    return JIM_OK;
-}
-
-
-static int Jim_JoinCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    const char *joinStr;
-    int joinStrLen;
-
-    if (argc != 2 && argc != 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "list ?joinString?");
-        return JIM_ERR;
-    }
-
-    if (argc == 2) {
-        joinStr = " ";
-        joinStrLen = 1;
-    }
-    else {
-        joinStr = Jim_GetString(argv[2], &joinStrLen);
-    }
-    Jim_SetResult(interp, Jim_ListJoin(interp, argv[1], joinStr, joinStrLen));
-    return JIM_OK;
-}
-
-
-static int Jim_FormatCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *objPtr;
-
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "formatString ?arg arg ...?");
-        return JIM_ERR;
-    }
-    objPtr = Jim_FormatString(interp, argv[1], argc - 2, argv + 2);
-    if (objPtr == NULL)
-        return JIM_ERR;
-    Jim_SetResult(interp, objPtr);
-    return JIM_OK;
-}
-
-
-static int Jim_ScanCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *listPtr, **outVec;
-    int outc, i;
-
-    if (argc < 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "string format ?varName varName ...?");
-        return JIM_ERR;
-    }
-    if (argv[2]->typePtr != &scanFmtStringObjType)
-        SetScanFmtFromAny(interp, argv[2]);
-    if (FormatGetError(argv[2]) != 0) {
-        Jim_SetResultString(interp, FormatGetError(argv[2]), -1);
-        return JIM_ERR;
-    }
-    if (argc > 3) {
-        int maxPos = FormatGetMaxPos(argv[2]);
-        int count = FormatGetCnvCount(argv[2]);
-
-        if (maxPos > argc - 3) {
-            Jim_SetResultString(interp, "\"%n$\" argument index out of range", -1);
-            return JIM_ERR;
-        }
-        else if (count > argc - 3) {
-            Jim_SetResultString(interp, "different numbers of variable names and "
-                "field specifiers", -1);
-            return JIM_ERR;
-        }
-        else if (count < argc - 3) {
-            Jim_SetResultString(interp, "variable is not assigned by any "
-                "conversion specifiers", -1);
-            return JIM_ERR;
-        }
-    }
-    listPtr = Jim_ScanString(interp, argv[1], argv[2], JIM_ERRMSG);
-    if (listPtr == 0)
-        return JIM_ERR;
-    if (argc > 3) {
-        int rc = JIM_OK;
-        int count = 0;
-
-        if (listPtr != 0 && listPtr != (Jim_Obj *)EOF) {
-            int len = Jim_ListLength(interp, listPtr);
-
-            if (len != 0) {
-                JimListGetElements(interp, listPtr, &outc, &outVec);
-                for (i = 0; i < outc; ++i) {
-                    if (Jim_Length(outVec[i]) > 0) {
-                        ++count;
-                        if (Jim_SetVariable(interp, argv[3 + i], outVec[i]) != JIM_OK) {
-                            rc = JIM_ERR;
-                        }
-                    }
-                }
-            }
-            Jim_FreeNewObj(interp, listPtr);
-        }
-        else {
-            count = -1;
-        }
-        if (rc == JIM_OK) {
-            Jim_SetResultInt(interp, count);
-        }
-        return rc;
-    }
-    else {
-        if (listPtr == (Jim_Obj *)EOF) {
-            Jim_SetResult(interp, Jim_NewListObj(interp, 0, 0));
-            return JIM_OK;
-        }
-        Jim_SetResult(interp, listPtr);
-    }
-    return JIM_OK;
-}
-
-
-static int Jim_ErrorCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    if (argc != 2 && argc != 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "message ?stacktrace?");
-        return JIM_ERR;
-    }
-    Jim_SetResult(interp, argv[1]);
-    if (argc == 3) {
-        JimSetStackTrace(interp, argv[2]);
-        return JIM_ERR;
-    }
-    return JIM_ERR;
-}
-
-
-static int Jim_LrangeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *objPtr;
-
-    if (argc != 4) {
-        Jim_WrongNumArgs(interp, 1, argv, "list first last");
-        return JIM_ERR;
-    }
-    if ((objPtr = Jim_ListRange(interp, argv[1], argv[2], argv[3])) == NULL)
-        return JIM_ERR;
-    Jim_SetResult(interp, objPtr);
-    return JIM_OK;
-}
-
-
-static int Jim_LrepeatCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *objPtr;
-    jim_wide count;
-
-    if (argc < 2 || Jim_GetWideExpr(interp, argv[1], &count) != JIM_OK || count < 0) {
-        Jim_WrongNumArgs(interp, 1, argv, "count ?value ...?");
-        return JIM_ERR;
-    }
-    if (count == 0 || argc == 2) {
-        Jim_SetEmptyResult(interp);
-        return JIM_OK;
-    }
-
-    argc -= 2;
-    argv += 2;
-
-    objPtr = Jim_NewListObj(interp, NULL, 0);
-    ListEnsureLength(objPtr, argc * count);
-    while (count--) {
-        ListInsertElements(objPtr, -1, argc, argv);
-    }
-
-    Jim_SetResult(interp, objPtr);
-    return JIM_OK;
-}
-
-char **Jim_GetEnviron(void)
-{
-#if defined(HAVE__NSGETENVIRON)
-    return *_NSGetEnviron();
-#elif defined(_environ)
-    return _environ;
-#else
-    #if !defined(NO_ENVIRON_EXTERN)
-    extern char **environ;
-    #endif
-    return environ;
-#endif
-}
-
-void Jim_SetEnviron(char **env)
-{
-#if defined(HAVE__NSGETENVIRON)
-    *_NSGetEnviron() = env;
-#elif defined(_environ)
-    _environ = env;
-#else
-    #if !defined(NO_ENVIRON_EXTERN)
-    extern char **environ;
-    #endif
-
-    environ = env;
-#endif
-}
-
-
-static int Jim_EnvCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    const char *key;
-    const char *val;
-
-    if (argc == 1) {
-        char **e = Jim_GetEnviron();
-
-        int i;
-        Jim_Obj *listObjPtr = Jim_NewListObj(interp, NULL, 0);
-
-        for (i = 0; e[i]; i++) {
-            const char *equals = strchr(e[i], '=');
-
-            if (equals) {
-                Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp, e[i],
-                        equals - e[i]));
-                Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp, equals + 1, -1));
-            }
-        }
-
-        Jim_SetResult(interp, listObjPtr);
-        return JIM_OK;
-    }
-
-    if (argc > 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "varName ?default?");
-        return JIM_ERR;
-    }
-    key = Jim_String(argv[1]);
-    val = getenv(key);
-    if (val == NULL) {
-        if (argc < 3) {
-            Jim_SetResultFormatted(interp, "environment variable \"%#s\" does not exist", argv[1]);
-            return JIM_ERR;
-        }
-        val = Jim_String(argv[2]);
-    }
-    Jim_SetResult(interp, Jim_NewStringObj(interp, val, -1));
-    return JIM_OK;
-}
-
-
-static int Jim_SourceCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    int retval;
-
-    if (argc != 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "fileName");
-        return JIM_ERR;
-    }
-    retval = Jim_EvalFile(interp, Jim_String(argv[1]));
-    if (retval == JIM_RETURN)
-        return JIM_OK;
-    return retval;
-}
-
-
-static int Jim_LreverseCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    Jim_Obj *revObjPtr, **ele;
-    int len;
-
-    if (argc != 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "list");
-        return JIM_ERR;
-    }
-    JimListGetElements(interp, argv[1], &len, &ele);
-    revObjPtr = Jim_NewListObj(interp, NULL, 0);
-    ListEnsureLength(revObjPtr, len);
-    len--;
-    while (len >= 0)
-        ListAppendElement(revObjPtr, ele[len--]);
-    Jim_SetResult(interp, revObjPtr);
-    return JIM_OK;
-}
-
-static int JimRangeLen(jim_wide start, jim_wide end, jim_wide step)
-{
-    jim_wide len;
-
-    if (step == 0)
-        return -1;
-    if (start == end)
-        return 0;
-    else if (step > 0 && start > end)
-        return -1;
-    else if (step < 0 && end > start)
-        return -1;
-    len = end - start;
-    if (len < 0)
-        len = -len;
-    if (step < 0)
-        step = -step;
-    len = 1 + ((len - 1) / step);
-    if (len > INT_MAX)
-        len = INT_MAX;
-    return (int)((len < 0) ? -1 : len);
-}
-
-
-static int Jim_RangeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    jim_wide start = 0, end, step = 1;
-    int len, i;
-    Jim_Obj *objPtr;
-
-    if (argc < 2 || argc > 4) {
-        Jim_WrongNumArgs(interp, 1, argv, "?start? end ?step?");
-        return JIM_ERR;
-    }
-    if (argc == 2) {
-        if (Jim_GetWideExpr(interp, argv[1], &end) != JIM_OK)
-            return JIM_ERR;
-    }
-    else {
-        if (Jim_GetWideExpr(interp, argv[1], &start) != JIM_OK ||
-            Jim_GetWideExpr(interp, argv[2], &end) != JIM_OK)
-            return JIM_ERR;
-        if (argc == 4 && Jim_GetWideExpr(interp, argv[3], &step) != JIM_OK)
-            return JIM_ERR;
-    }
-    if ((len = JimRangeLen(start, end, step)) == -1) {
-        Jim_SetResultString(interp, "Invalid (infinite?) range specified", -1);
-        return JIM_ERR;
-    }
-    objPtr = Jim_NewListObj(interp, NULL, 0);
-    ListEnsureLength(objPtr, len);
-    for (i = 0; i < len; i++)
-        ListAppendElement(objPtr, Jim_NewIntObj(interp, start + i * step));
-    Jim_SetResult(interp, objPtr);
-    return JIM_OK;
-}
-
-
-static int Jim_RandCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    jim_wide min = 0, max = 0, len, maxMul;
-
-    if (argc < 1 || argc > 3) {
-        Jim_WrongNumArgs(interp, 1, argv, "?min? max");
-        return JIM_ERR;
-    }
-    if (argc == 1) {
-        max = JIM_WIDE_MAX;
-    } else if (argc == 2) {
-        if (Jim_GetWideExpr(interp, argv[1], &max) != JIM_OK)
-            return JIM_ERR;
-    } else if (argc == 3) {
-        if (Jim_GetWideExpr(interp, argv[1], &min) != JIM_OK ||
-            Jim_GetWideExpr(interp, argv[2], &max) != JIM_OK)
-            return JIM_ERR;
-    }
-    len = max-min;
-    if (len < 0) {
-        Jim_SetResultString(interp, "Invalid arguments (max < min)", -1);
-        return JIM_ERR;
-    }
-    maxMul = JIM_WIDE_MAX - (len ? (JIM_WIDE_MAX%len) : 0);
-    while (1) {
-        jim_wide r;
-
-        JimRandomBytes(interp, &r, sizeof(jim_wide));
-        if (r < 0 || r >= maxMul) continue;
-        r = (len == 0) ? 0 : r%len;
-        Jim_SetResultInt(interp, min+r);
-        return JIM_OK;
-    }
-}
-
-static const struct {
-    const char *name;
-    Jim_CmdProc *cmdProc;
-} Jim_CoreCommandsTable[] = {
-    {"alias", Jim_AliasCoreCommand},
-    {"set", Jim_SetCoreCommand},
-    {"unset", Jim_UnsetCoreCommand},
-    {"puts", Jim_PutsCoreCommand},
-    {"+", Jim_AddCoreCommand},
-    {"*", Jim_MulCoreCommand},
-    {"-", Jim_SubCoreCommand},
-    {"/", Jim_DivCoreCommand},
-    {"incr", Jim_IncrCoreCommand},
-    {"while", Jim_WhileCoreCommand},
-    {"loop", Jim_LoopCoreCommand},
-    {"for", Jim_ForCoreCommand},
-    {"foreach", Jim_ForeachCoreCommand},
-    {"lmap", Jim_LmapCoreCommand},
-    {"lassign", Jim_LassignCoreCommand},
-    {"if", Jim_IfCoreCommand},
-    {"switch", Jim_SwitchCoreCommand},
-    {"list", Jim_ListCoreCommand},
-    {"lindex", Jim_LindexCoreCommand},
-    {"lset", Jim_LsetCoreCommand},
-    {"lsearch", Jim_LsearchCoreCommand},
-    {"llength", Jim_LlengthCoreCommand},
-    {"lappend", Jim_LappendCoreCommand},
-    {"linsert", Jim_LinsertCoreCommand},
-    {"lreplace", Jim_LreplaceCoreCommand},
-    {"lsort", Jim_LsortCoreCommand},
-    {"append", Jim_AppendCoreCommand},
-    {"eval", Jim_EvalCoreCommand},
-    {"uplevel", Jim_UplevelCoreCommand},
-    {"expr", Jim_ExprCoreCommand},
-    {"break", Jim_BreakCoreCommand},
-    {"continue", Jim_ContinueCoreCommand},
-    {"proc", Jim_ProcCoreCommand},
-    {"xtrace", Jim_XtraceCoreCommand},
-    {"concat", Jim_ConcatCoreCommand},
-    {"return", Jim_ReturnCoreCommand},
-    {"upvar", Jim_UpvarCoreCommand},
-    {"global", Jim_GlobalCoreCommand},
-    {"string", Jim_StringCoreCommand},
-    {"time", Jim_TimeCoreCommand},
-    {"timerate", Jim_TimeRateCoreCommand},
-    {"exit", Jim_ExitCoreCommand},
-    {"catch", Jim_CatchCoreCommand},
-    {"try", Jim_TryCoreCommand},
-#ifdef JIM_REFERENCES
-    {"ref", Jim_RefCoreCommand},
-    {"getref", Jim_GetrefCoreCommand},
-    {"setref", Jim_SetrefCoreCommand},
-    {"finalize", Jim_FinalizeCoreCommand},
-    {"collect", Jim_CollectCoreCommand},
-#endif
-    {"rename", Jim_RenameCoreCommand},
-    {"dict", Jim_DictCoreCommand},
-    {"subst", Jim_SubstCoreCommand},
-    {"info", Jim_InfoCoreCommand},
-    {"exists", Jim_ExistsCoreCommand},
-    {"split", Jim_SplitCoreCommand},
-    {"join", Jim_JoinCoreCommand},
-    {"format", Jim_FormatCoreCommand},
-    {"scan", Jim_ScanCoreCommand},
-    {"error", Jim_ErrorCoreCommand},
-    {"lrange", Jim_LrangeCoreCommand},
-    {"lrepeat", Jim_LrepeatCoreCommand},
-    {"env", Jim_EnvCoreCommand},
-    {"source", Jim_SourceCoreCommand},
-    {"lreverse", Jim_LreverseCoreCommand},
-    {"range", Jim_RangeCoreCommand},
-    {"rand", Jim_RandCoreCommand},
-    {"tailcall", Jim_TailcallCoreCommand},
-    {"local", Jim_LocalCoreCommand},
-    {"upcall", Jim_UpcallCoreCommand},
-    {"apply", Jim_ApplyCoreCommand},
-    {"stacktrace", Jim_StacktraceCoreCommand},
-    {NULL, NULL},
-};
-
-void Jim_RegisterCoreCommands(Jim_Interp *interp)
-{
-    int i = 0;
-
-    while (Jim_CoreCommandsTable[i].name != NULL) {
-        Jim_CreateCommand(interp,
-            Jim_CoreCommandsTable[i].name, Jim_CoreCommandsTable[i].cmdProc, NULL, NULL);
-        i++;
-    }
-}
-
-void Jim_MakeErrorMessage(Jim_Interp *interp)
-{
-    Jim_Obj *argv[2];
-
-    argv[0] = Jim_NewStringObj(interp, "errorInfo", -1);
-    argv[1] = interp->result;
-
-    Jim_EvalObjVector(interp, 2, argv);
-}
-
-static char **JimSortStringTable(const char *const *tablePtr)
-{
-    int count;
-    char **tablePtrSorted;
-
-
-    for (count = 0; tablePtr[count]; count++) {
-    }
-
-
-    tablePtrSorted = Jim_Alloc(sizeof(char *) * (count + 1));
-    memcpy(tablePtrSorted, tablePtr, sizeof(char *) * count);
-    qsort(tablePtrSorted, count, sizeof(char *), qsortCompareStringPointers);
-    tablePtrSorted[count] = NULL;
-
-    return tablePtrSorted;
-}
-
-static void JimSetFailedEnumResult(Jim_Interp *interp, const char *arg, const char *badtype,
-    const char *prefix, const char *const *tablePtr, const char *name)
-{
-    char **tablePtrSorted;
-    int i;
-
-    if (name == NULL) {
-        name = "option";
-    }
-
-    Jim_SetResultFormatted(interp, "%s%s \"%s\": must be ", badtype, name, arg);
-    tablePtrSorted = JimSortStringTable(tablePtr);
-    for (i = 0; tablePtrSorted[i]; i++) {
-        if (tablePtrSorted[i + 1] == NULL && i > 0) {
-            Jim_AppendString(interp, Jim_GetResult(interp), "or ", -1);
-        }
-        Jim_AppendStrings(interp, Jim_GetResult(interp), prefix, tablePtrSorted[i], NULL);
-        if (tablePtrSorted[i + 1]) {
-            Jim_AppendString(interp, Jim_GetResult(interp), ", ", -1);
-        }
-    }
-    Jim_Free(tablePtrSorted);
-}
-
-
-int Jim_CheckShowCommands(Jim_Interp *interp, Jim_Obj *objPtr, const char *const *tablePtr)
-{
-    if (Jim_CompareStringImmediate(interp, objPtr, "-commands")) {
-        int i;
-        char **tablePtrSorted = JimSortStringTable(tablePtr);
-        Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
-        for (i = 0; tablePtrSorted[i]; i++) {
-            Jim_ListAppendElement(interp, Jim_GetResult(interp), Jim_NewStringObj(interp, tablePtrSorted[i], -1));
-        }
-        Jim_Free(tablePtrSorted);
-        return JIM_OK;
-    }
-    return JIM_ERR;
-}
-
-static const Jim_ObjType getEnumObjType = {
-    "get-enum",
-    NULL,
-    NULL,
-    NULL,
-    JIM_TYPE_REFERENCES
-};
-
-int Jim_GetEnum(Jim_Interp *interp, Jim_Obj *objPtr,
-    const char *const *tablePtr, int *indexPtr, const char *name, int flags)
-{
-    const char *bad = "bad ";
-    const char *const *entryPtr = NULL;
-    int i;
-    int match = -1;
-    int arglen;
-    const char *arg;
-
-    if (objPtr->typePtr == &getEnumObjType) {
-        if (objPtr->internalRep.ptrIntValue.ptr == tablePtr && objPtr->internalRep.ptrIntValue.int1 == flags) {
-            *indexPtr = objPtr->internalRep.ptrIntValue.int2;
-            return JIM_OK;
-        }
-    }
-
-    arg = Jim_GetString(objPtr, &arglen);
-
-    *indexPtr = -1;
-
-    for (entryPtr = tablePtr, i = 0; *entryPtr != NULL; entryPtr++, i++) {
-        if (Jim_CompareStringImmediate(interp, objPtr, *entryPtr)) {
-
-            match = i;
-            goto found;
-        }
-        if (flags & JIM_ENUM_ABBREV) {
-            if (strncmp(arg, *entryPtr, arglen) == 0) {
-                if (*arg == '-' && arglen == 1) {
-                    break;
-                }
-                if (match >= 0) {
-                    bad = "ambiguous ";
-                    goto ambiguous;
-                }
-                match = i;
-            }
-        }
-    }
-
-
-    if (match >= 0) {
-  found:
-
-        Jim_FreeIntRep(interp, objPtr);
-        objPtr->typePtr = &getEnumObjType;
-        objPtr->internalRep.ptrIntValue.ptr = (void *)tablePtr;
-        objPtr->internalRep.ptrIntValue.int1 = flags;
-        objPtr->internalRep.ptrIntValue.int2 = match;
-
-        *indexPtr = match;
-        return JIM_OK;
-    }
-
-  ambiguous:
-    if (flags & JIM_ERRMSG) {
-        JimSetFailedEnumResult(interp, arg, bad, "", tablePtr, name);
-    }
-    return JIM_ERR;
-}
-
-int Jim_FindByName(const char *name, const char * const array[], size_t len)
-{
-    int i;
-
-    for (i = 0; i < (int)len; i++) {
-        if (array[i] && strcmp(array[i], name) == 0) {
-            return i;
-        }
-    }
-    return -1;
-}
-
-int Jim_IsDict(Jim_Obj *objPtr)
-{
-    return objPtr->typePtr == &dictObjType;
-}
-
-int Jim_IsList(Jim_Obj *objPtr)
-{
-    return objPtr->typePtr == &listObjType;
-}
-
-void Jim_SetResultFormatted(Jim_Interp *interp, const char *format, ...)
-{
-
-    int len = strlen(format);
-    int extra = 0;
-    int n = 0;
-    const char *params[5];
-    int nobjparam = 0;
-    Jim_Obj *objparam[5];
-    char *buf;
-    va_list args;
-    int i;
-
-    va_start(args, format);
-
-    for (i = 0; i < len && n < 5; i++) {
-        int l;
-
-        if (strncmp(format + i, "%s", 2) == 0) {
-            params[n] = va_arg(args, char *);
-
-            l = strlen(params[n]);
-        }
-        else if (strncmp(format + i, "%#s", 3) == 0) {
-            Jim_Obj *objPtr = va_arg(args, Jim_Obj *);
-
-            params[n] = Jim_GetString(objPtr, &l);
-            objparam[nobjparam++] = objPtr;
-            Jim_IncrRefCount(objPtr);
-        }
-        else {
-            if (format[i] == '%') {
-                i++;
-            }
-            continue;
-        }
-        n++;
-        extra += l;
-    }
-
-    len += extra;
-    buf = Jim_Alloc(len + 1);
-    len = snprintf(buf, len + 1, format, params[0], params[1], params[2], params[3], params[4]);
-
-    va_end(args);
-
-    Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, buf, len));
-
-    for (i = 0; i < nobjparam; i++) {
-        Jim_DecrRefCount(interp, objparam[i]);
-    }
-}
-
-int Jim_CheckAbiVersion(Jim_Interp *interp, int abi_version)
-{
-    if (abi_version != JIM_ABI_VERSION) {
-        Jim_SetResultString(interp, "ABI version mismatch", -1);
-        return JIM_ERR;
-    }
-    return JIM_OK;
-}
-
-
-#ifndef jim_ext_package
-int Jim_PackageProvide(Jim_Interp *interp, const char *name, const char *ver, int flags)
-{
-    return JIM_OK;
-}
-#endif
-#ifndef jim_ext_aio
-int Jim_AioFilehandle(Jim_Interp *interp, Jim_Obj *fhObj)
-{
-    return -1;
-}
-#endif
-
-
-#include <stdio.h>
-#include <string.h>
-
-
-static int subcmd_null(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-
-    return JIM_OK;
-}
-
-static const jim_subcmd_type dummy_subcmd = {
-    "dummy", NULL, subcmd_null, 0, 0, JIM_MODFLAG_HIDDEN
-};
-
-static Jim_Obj *subcmd_cmd_list(Jim_Interp *interp, const jim_subcmd_type * ct, const char *sep)
-{
-
-    Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
-    Jim_Obj *sortCmd[2];
-
-    for (; ct->cmd; ct++) {
-        if (!(ct->flags & JIM_MODFLAG_HIDDEN)) {
-            Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, ct->cmd, -1));
-        }
-    }
-
-
-    sortCmd[0] = Jim_NewStringObj(interp, "lsort", -1);
-    sortCmd[1] = listObj;
-
-    if (Jim_EvalObjVector(interp, 2, sortCmd) == JIM_OK) {
-        return Jim_ListJoin(interp, Jim_GetResult(interp), sep, strlen(sep));
-    }
-
-    return Jim_GetResult(interp);
-}
-
-static void bad_subcmd(Jim_Interp *interp, const jim_subcmd_type * command_table, const char *type,
-    Jim_Obj *cmd, Jim_Obj *subcmd)
-{
-    Jim_SetResultFormatted(interp, "%#s, %s command \"%#s\": should be %#s", cmd, type,
-        subcmd, subcmd_cmd_list(interp, command_table, ", "));
-}
-
-static void show_cmd_usage(Jim_Interp *interp, const jim_subcmd_type * command_table, int argc,
-    Jim_Obj *const *argv)
-{
-    Jim_SetResultFormatted(interp, "Usage: \"%#s command ... \", where command is one of: %#s",
-        argv[0], subcmd_cmd_list(interp, command_table, ", "));
-}
-
-static void add_cmd_usage(Jim_Interp *interp, const jim_subcmd_type * ct, Jim_Obj *cmd)
-{
-    if (cmd) {
-        Jim_AppendStrings(interp, Jim_GetResult(interp), Jim_String(cmd), " ", NULL);
-    }
-    Jim_AppendStrings(interp, Jim_GetResult(interp), ct->cmd, NULL);
-    if (ct->args && *ct->args) {
-        Jim_AppendStrings(interp, Jim_GetResult(interp), " ", ct->args, NULL);
-    }
-}
-
-void Jim_SubCmdArgError(Jim_Interp *interp, const jim_subcmd_type * ct, Jim_Obj *subcmd)
-{
-    Jim_SetResultString(interp, "wrong # args: should be \"", -1);
-    add_cmd_usage(interp, ct, subcmd);
-    Jim_AppendStrings(interp, Jim_GetResult(interp), "\"", NULL);
-}
-
-static const Jim_ObjType subcmdLookupObjType = {
-    "subcmd-lookup",
-    NULL,
-    NULL,
-    NULL,
-    JIM_TYPE_REFERENCES
-};
-
-const jim_subcmd_type *Jim_ParseSubCmd(Jim_Interp *interp, const jim_subcmd_type * command_table,
-    int argc, Jim_Obj *const *argv)
-{
-    const jim_subcmd_type *ct;
-    const jim_subcmd_type *partial = 0;
-    int cmdlen;
-    Jim_Obj *cmd;
-    const char *cmdstr;
-    int help = 0;
-    int argsok = 1;
-
-    if (argc < 2) {
-        Jim_SetResultFormatted(interp, "wrong # args: should be \"%#s command ...\"\n"
-            "Use \"%#s -help ?command?\" for help", argv[0], argv[0]);
-        return 0;
-    }
-
-    cmd = argv[1];
-
-
-    if (cmd->typePtr == &subcmdLookupObjType) {
-        if (cmd->internalRep.ptrIntValue.ptr == command_table) {
-            ct = command_table + cmd->internalRep.ptrIntValue.int1;
-            goto found;
-        }
-    }
-
-
-    if (Jim_CompareStringImmediate(interp, cmd, "-help")) {
-        if (argc == 2) {
-
-            show_cmd_usage(interp, command_table, argc, argv);
-            return &dummy_subcmd;
-        }
-        help = 1;
-
-
-        cmd = argv[2];
-    }
-
-
-    if (Jim_CompareStringImmediate(interp, cmd, "-commands")) {
-        Jim_SetResult(interp, subcmd_cmd_list(interp, command_table, " "));
-        return &dummy_subcmd;
-    }
-
-    cmdstr = Jim_GetString(cmd, &cmdlen);
-
-    for (ct = command_table; ct->cmd; ct++) {
-        if (Jim_CompareStringImmediate(interp, cmd, ct->cmd)) {
-
-            break;
-        }
-        if (strncmp(cmdstr, ct->cmd, cmdlen) == 0) {
-            if (partial) {
-
-                if (help) {
-
-                    show_cmd_usage(interp, command_table, argc, argv);
-                    return &dummy_subcmd;
-                }
-                bad_subcmd(interp, command_table, "ambiguous", argv[0], argv[1 + help]);
-                return 0;
-            }
-            partial = ct;
-        }
-        continue;
-    }
-
-
-    if (partial && !ct->cmd) {
-        ct = partial;
-    }
-
-    if (!ct->cmd) {
-
-        if (help) {
-
-            show_cmd_usage(interp, command_table, argc, argv);
-            return &dummy_subcmd;
-        }
-        bad_subcmd(interp, command_table, "unknown", argv[0], argv[1 + help]);
-        return 0;
-    }
-
-    if (help) {
-        Jim_SetResultString(interp, "Usage: ", -1);
-
-        add_cmd_usage(interp, ct, argv[0]);
-        return &dummy_subcmd;
-    }
-
-
-    Jim_FreeIntRep(interp, cmd);
-    cmd->typePtr = &subcmdLookupObjType;
-    cmd->internalRep.ptrIntValue.ptr = (void *)command_table;
-    cmd->internalRep.ptrIntValue.int1 = ct - command_table;
-
-found:
-
-
-    if (argc - 2 < ct->minargs) {
-        argsok = 0;
-    }
-    else if (ct->maxargs >= 0 && argc - 2 > ct->maxargs) {
-        argsok = 0;
-    }
-    else if (ct->maxargs < -1 && (argc - 2) % -ct->maxargs != 0) {
-
-        argsok = 0;
-    }
-    if (!argsok) {
-        Jim_SetResultString(interp, "wrong # args: should be \"", -1);
-
-        add_cmd_usage(interp, ct, argv[0]);
-        Jim_AppendStrings(interp, Jim_GetResult(interp), "\"", NULL);
-
-        return 0;
-    }
-
-
-    return ct;
-}
-
-int Jim_CallSubCmd(Jim_Interp *interp, const jim_subcmd_type * ct, int argc, Jim_Obj *const *argv)
-{
-    int ret = JIM_ERR;
-
-    if (ct) {
-        if (ct->flags & JIM_MODFLAG_FULLARGV) {
-            ret = ct->function(interp, argc, argv);
-        }
-        else {
-            ret = ct->function(interp, argc - 2, argv + 2);
-        }
-        if (ret < 0) {
-            Jim_SubCmdArgError(interp, ct, argv[0]);
-            ret = JIM_ERR;
-        }
-    }
-    return ret;
-}
-
-int Jim_SubCmdProc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    const jim_subcmd_type *ct =
-        Jim_ParseSubCmd(interp, (const jim_subcmd_type *)Jim_CmdPrivData(interp), argc, argv);
-
-    return Jim_CallSubCmd(interp, ct, argc, argv);
-}
-
-#include <ctype.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <assert.h>
-
-
-int utf8_fromunicode(char *p, unsigned uc)
-{
-    if (uc <= 0x7f) {
-        *p = uc;
-        return 1;
-    }
-    else if (uc <= 0x7ff) {
-        *p++ = 0xc0 | ((uc & 0x7c0) >> 6);
-        *p = 0x80 | (uc & 0x3f);
-        return 2;
-    }
-    else if (uc <= 0xffff) {
-        *p++ = 0xe0 | ((uc & 0xf000) >> 12);
-        *p++ = 0x80 | ((uc & 0xfc0) >> 6);
-        *p = 0x80 | (uc & 0x3f);
-        return 3;
-    }
-
-    else {
-        *p++ = 0xf0 | ((uc & 0x1c0000) >> 18);
-        *p++ = 0x80 | ((uc & 0x3f000) >> 12);
-        *p++ = 0x80 | ((uc & 0xfc0) >> 6);
-        *p = 0x80 | (uc & 0x3f);
-        return 4;
-    }
-}
-
-#include <ctype.h>
-#include <string.h>
-#include <stdio.h>
-
-
-#define JIM_INTEGER_SPACE 24
-#define MAX_FLOAT_WIDTH 320
-
-Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_Obj *const *objv)
-{
-    const char *span, *format, *formatEnd, *msg;
-    int numBytes = 0, objIndex = 0, gotXpg = 0, gotSequential = 0;
-    static const char * const mixedXPG =
-            "cannot mix \"%\" and \"%n$\" conversion specifiers";
-    static const char * const badIndex[2] = {
-        "not enough arguments for all format specifiers",
-        "\"%n$\" argument index out of range"
-    };
-    int formatLen;
-    Jim_Obj *resultPtr;
-
-    char *num_buffer = NULL;
-    int num_buffer_size = 0;
-
-    span = format = Jim_GetString(fmtObjPtr, &formatLen);
-    formatEnd = format + formatLen;
-    resultPtr = Jim_NewEmptyStringObj(interp);
-
-    while (format != formatEnd) {
-        char *end;
-        int gotMinus, sawFlag;
-        int gotPrecision, useShort;
-        long width, precision;
-        int newXpg;
-        int ch;
-        int step;
-        int doubleType;
-        char pad = ' ';
-        char spec[2*JIM_INTEGER_SPACE + 12];
-        char *p;
-
-        int formatted_chars;
-        int formatted_bytes;
-        const char *formatted_buf;
-
-        step = utf8_tounicode(format, &ch);
-        format += step;
-        if (ch != '%') {
-            numBytes += step;
-            continue;
-        }
-        if (numBytes) {
-            Jim_AppendString(interp, resultPtr, span, numBytes);
-            numBytes = 0;
-        }
-
-
-        step = utf8_tounicode(format, &ch);
-        if (ch == '%') {
-            span = format;
-            numBytes = step;
-            format += step;
-            continue;
-        }
-
-
-        newXpg = 0;
-        if (isdigit(ch)) {
-            int position = strtoul(format, &end, 10);
-            if (*end == '$') {
-                newXpg = 1;
-                objIndex = position - 1;
-                format = end + 1;
-                step = utf8_tounicode(format, &ch);
-            }
-        }
-        if (newXpg) {
-            if (gotSequential) {
-                msg = mixedXPG;
-                goto errorMsg;
-            }
-            gotXpg = 1;
-        } else {
-            if (gotXpg) {
-                msg = mixedXPG;
-                goto errorMsg;
-            }
-            gotSequential = 1;
-        }
-        if ((objIndex < 0) || (objIndex >= objc)) {
-            msg = badIndex[gotXpg];
-            goto errorMsg;
-        }
-
-        p = spec;
-        *p++ = '%';
-
-        gotMinus = 0;
-        sawFlag = 1;
-        do {
-            switch (ch) {
-            case '-':
-                gotMinus = 1;
-                break;
-            case '0':
-                pad = ch;
-                break;
-            case ' ':
-            case '+':
-            case '#':
-                break;
-            default:
-                sawFlag = 0;
-                continue;
-            }
-            *p++ = ch;
-            format += step;
-            step = utf8_tounicode(format, &ch);
-
-        } while (sawFlag && (p - spec <= 5));
-
-
-        width = 0;
-        if (isdigit(ch)) {
-            width = strtoul(format, &end, 10);
-            format = end;
-            step = utf8_tounicode(format, &ch);
-        } else if (ch == '*') {
-            if (objIndex >= objc - 1) {
-                msg = badIndex[gotXpg];
-                goto errorMsg;
-            }
-            if (Jim_GetLong(interp, objv[objIndex], &width) != JIM_OK) {
-                goto error;
-            }
-            if (width < 0) {
-                width = -width;
-                if (!gotMinus) {
-                    *p++ = '-';
-                    gotMinus = 1;
-                }
-            }
-            objIndex++;
-            format += step;
-            step = utf8_tounicode(format, &ch);
-        }
-
-
-        gotPrecision = precision = 0;
-        if (ch == '.') {
-            gotPrecision = 1;
-            format += step;
-            step = utf8_tounicode(format, &ch);
-        }
-        if (isdigit(ch)) {
-            precision = strtoul(format, &end, 10);
-            format = end;
-            step = utf8_tounicode(format, &ch);
-        } else if (ch == '*') {
-            if (objIndex >= objc - 1) {
-                msg = badIndex[gotXpg];
-                goto errorMsg;
-            }
-            if (Jim_GetLong(interp, objv[objIndex], &precision) != JIM_OK) {
-                goto error;
-            }
-
-
-            if (precision < 0) {
-                precision = 0;
-            }
-            objIndex++;
-            format += step;
-            step = utf8_tounicode(format, &ch);
-        }
-
-
-        useShort = 0;
-        if (ch == 'h') {
-            useShort = 1;
-            format += step;
-            step = utf8_tounicode(format, &ch);
-        } else if (ch == 'l') {
-
-            format += step;
-            step = utf8_tounicode(format, &ch);
-            if (ch == 'l') {
-                format += step;
-                step = utf8_tounicode(format, &ch);
-            }
-        }
-
-        format += step;
-        span = format;
-
-
-        if (ch == 'i') {
-            ch = 'd';
-        }
-
-        doubleType = 0;
-
-        switch (ch) {
-        case '\0':
-            msg = "format string ended in middle of field specifier";
-            goto errorMsg;
-        case 's': {
-            formatted_buf = Jim_GetString(objv[objIndex], &formatted_bytes);
-            formatted_chars = Jim_Utf8Length(interp, objv[objIndex]);
-            if (gotPrecision && (precision < formatted_chars)) {
-
-                formatted_chars = precision;
-                formatted_bytes = utf8_index(formatted_buf, precision);
-            }
-            break;
-        }
-        case 'c': {
-            jim_wide code;
-
-            if (Jim_GetWide(interp, objv[objIndex], &code) != JIM_OK) {
-                goto error;
-            }
-
-            formatted_bytes = utf8_getchars(spec, code);
-            formatted_buf = spec;
-            formatted_chars = 1;
-            break;
-        }
-        case 'b': {
-                unsigned jim_wide w;
-                int length;
-                int i;
-                int j;
-
-                if (Jim_GetWide(interp, objv[objIndex], (jim_wide *)&w) != JIM_OK) {
-                    goto error;
-                }
-                length = sizeof(w) * 8;
-
-
-
-                if (num_buffer_size < length + 1) {
-                    num_buffer_size = length + 1;
-                    num_buffer = Jim_Realloc(num_buffer, num_buffer_size);
-                }
-
-                j = 0;
-                for (i = length; i > 0; ) {
-                        i--;
-                        if (w & ((unsigned jim_wide)1 << i)) {
-                                num_buffer[j++] = '1';
-                        }
-                        else if (j || i == 0) {
-                                num_buffer[j++] = '0';
-                        }
-                }
-                num_buffer[j] = 0;
-                formatted_chars = formatted_bytes = j;
-                formatted_buf = num_buffer;
-                break;
-        }
-
-        case 'e':
-        case 'E':
-        case 'f':
-        case 'g':
-        case 'G':
-            doubleType = 1;
-
-        case 'd':
-        case 'u':
-        case 'o':
-        case 'x':
-        case 'X': {
-            jim_wide w;
-            double d;
-            int length;
-
-
-            if (width) {
-                p += sprintf(p, "%ld", width);
-            }
-            if (gotPrecision) {
-                p += sprintf(p, ".%ld", precision);
-            }
-
-
-            if (doubleType) {
-                if (Jim_GetDouble(interp, objv[objIndex], &d) != JIM_OK) {
-                    goto error;
-                }
-                length = MAX_FLOAT_WIDTH;
-            }
-            else {
-                if (Jim_GetWide(interp, objv[objIndex], &w) != JIM_OK) {
-                    goto error;
-                }
-                length = JIM_INTEGER_SPACE;
-                if (useShort) {
-                    if (ch == 'd') {
-                        w = (short)w;
-                    }
-                    else {
-                        w = (unsigned short)w;
-                    }
-                }
-                *p++ = 'l';
-#ifdef HAVE_LONG_LONG
-                if (sizeof(long long) == sizeof(jim_wide)) {
-                    *p++ = 'l';
-                }
-#endif
-            }
-
-            *p++ = (char) ch;
-            *p = '\0';
-
-
-            if (width > 10000 || length > 10000 || precision > 10000) {
-                Jim_SetResultString(interp, "format too long", -1);
-                goto error;
-            }
-
-
-
-            if (width > length) {
-                length = width;
-            }
-            if (gotPrecision) {
-                length += precision;
-            }
-
-
-            if (num_buffer_size < length + 1) {
-                num_buffer_size = length + 1;
-                num_buffer = Jim_Realloc(num_buffer, num_buffer_size);
-            }
-
-            if (doubleType) {
-                snprintf(num_buffer, length + 1, spec, d);
-            }
-            else {
-                formatted_bytes = snprintf(num_buffer, length + 1, spec, w);
-            }
-            formatted_chars = formatted_bytes = strlen(num_buffer);
-            formatted_buf = num_buffer;
-            break;
-        }
-
-        default: {
-
-            spec[0] = ch;
-            spec[1] = '\0';
-            Jim_SetResultFormatted(interp, "bad field specifier \"%s\"", spec);
-            goto error;
-        }
-        }
-
-        if (!gotMinus) {
-            while (formatted_chars < width) {
-                Jim_AppendString(interp, resultPtr, &pad, 1);
-                formatted_chars++;
-            }
-        }
-
-        Jim_AppendString(interp, resultPtr, formatted_buf, formatted_bytes);
-
-        while (formatted_chars < width) {
-            Jim_AppendString(interp, resultPtr, &pad, 1);
-            formatted_chars++;
-        }
-
-        objIndex += gotSequential;
-    }
-    if (numBytes) {
-        Jim_AppendString(interp, resultPtr, span, numBytes);
-    }
-
-    Jim_Free(num_buffer);
-    return resultPtr;
-
-  errorMsg:
-    Jim_SetResultString(interp, msg, -1);
-  error:
-    Jim_FreeNewObj(interp, resultPtr);
-    Jim_Free(num_buffer);
-    return NULL;
-}
-
-
-#if defined(JIM_REGEXP)
-#include <stdio.h>
-#include <ctype.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-
-#define REG_MAX_PAREN 100
-
-
-
-#define	END	0
-#define	BOL	1
-#define	EOL	2
-#define	ANY	3
-#define	ANYOF	4
-#define	ANYBUT	5
-#define	BRANCH	6
-#define	BACK	7
-#define	EXACTLY	8
-#define	NOTHING	9
-#define	REP	10
-#define	REPMIN	11
-#define	REPX	12
-#define	REPXMIN	13
-#define	BOLX	14
-#define	EOLX	15
-#define	WORDA	16
-#define	WORDZ	17
-
-#define	OPENNC 	1000
-#define	OPEN   	1001
-
-
-
-
-#define	CLOSENC	2000
-#define	CLOSE	2001
-#define	CLOSE_END	(CLOSE+REG_MAX_PAREN)
-
-#define	REG_MAGIC	0xFADED00D
-
-
-#define	OP(preg, p)	(preg->program[p])
-#define	NEXT(preg, p)	(preg->program[p + 1])
-#define	OPERAND(p)	((p) + 2)
-
-
-
-
-#define	FAIL(R,M)	{ (R)->err = (M); return (M); }
-#define	ISMULT(c)	((c) == '*' || (c) == '+' || (c) == '?' || (c) == '{')
-#define	META		"^$.[()|?{+*"
-
-#define	HASWIDTH	1
-#define	SIMPLE		2
-#define	SPSTART		4
-#define	WORST		0
-
-#define MAX_REP_COUNT 1000000
-
-static int reg(regex_t *preg, int paren, int *flagp );
-static int regpiece(regex_t *preg, int *flagp );
-static int regbranch(regex_t *preg, int *flagp );
-static int regatom(regex_t *preg, int *flagp );
-static int regnode(regex_t *preg, int op );
-static int regnext(regex_t *preg, int p );
-static void regc(regex_t *preg, int b );
-static int reginsert(regex_t *preg, int op, int size, int opnd );
-static void regtail(regex_t *preg, int p, int val);
-static void regoptail(regex_t *preg, int p, int val );
-static int regopsize(regex_t *preg, int p );
-
-static int reg_range_find(const int *string, int c);
-static const char *str_find(const char *string, int c, int nocase);
-static int prefix_cmp(const int *prog, int proglen, const char *string, int nocase);
-
-
-#ifdef DEBUG
-static int regnarrate = 0;
-static void regdump(regex_t *preg);
-static const char *regprop( int op );
-#endif
-
-
-static int str_int_len(const int *seq)
-{
-	int n = 0;
-	while (*seq++) {
-		n++;
-	}
-	return n;
-}
-
-int jim_regcomp(regex_t *preg, const char *exp, int cflags)
-{
-	int scan;
-	int longest;
-	unsigned len;
-	int flags;
-
-#ifdef DEBUG
-	fprintf(stderr, "Compiling: '%s'\n", exp);
-#endif
-	memset(preg, 0, sizeof(*preg));
-
-	if (exp == NULL)
-		FAIL(preg, REG_ERR_NULL_ARGUMENT);
-
-
-	preg->cflags = cflags;
-	preg->regparse = exp;
-
-
-	preg->proglen = (strlen(exp) + 1) * 5;
-	preg->program = malloc(preg->proglen * sizeof(int));
-	if (preg->program == NULL)
-		FAIL(preg, REG_ERR_NOMEM);
-
-	regc(preg, REG_MAGIC);
-	if (reg(preg, 0, &flags) == 0) {
-		return preg->err;
-	}
-
-
-	if (preg->re_nsub >= REG_MAX_PAREN)
-		FAIL(preg,REG_ERR_TOO_BIG);
-
-
-	preg->regstart = 0;
-	preg->reganch = 0;
-	preg->regmust = 0;
-	preg->regmlen = 0;
-	scan = 1;
-	if (OP(preg, regnext(preg, scan)) == END) {
-		scan = OPERAND(scan);
-
-
-		if (OP(preg, scan) == EXACTLY) {
-			preg->regstart = preg->program[OPERAND(scan)];
-		}
-		else if (OP(preg, scan) == BOL)
-			preg->reganch++;
-
-		if (flags&SPSTART) {
-			longest = 0;
-			len = 0;
-			for (; scan != 0; scan = regnext(preg, scan)) {
-				if (OP(preg, scan) == EXACTLY) {
-					int plen = str_int_len(preg->program + OPERAND(scan));
-					if (plen >= len) {
-						longest = OPERAND(scan);
-						len = plen;
-					}
-				}
-			}
-			preg->regmust = longest;
-			preg->regmlen = len;
-		}
-	}
-
-#ifdef DEBUG
-	regdump(preg);
-#endif
-
-	return 0;
-}
-
-static int reg(regex_t *preg, int paren, int *flagp )
-{
-	int ret;
-	int br;
-	int ender;
-	int parno = 0;
-	int flags;
-
-	*flagp = HASWIDTH;
-
-
-	if (paren) {
-		if (preg->regparse[0] == '?' && preg->regparse[1] == ':') {
-
-			preg->regparse += 2;
-			parno = -1;
-		}
-		else {
-			parno = ++preg->re_nsub;
-		}
-		ret = regnode(preg, OPEN+parno);
-	} else
-		ret = 0;
-
-
-	br = regbranch(preg, &flags);
-	if (br == 0)
-		return 0;
-	if (ret != 0)
-		regtail(preg, ret, br);
-	else
-		ret = br;
-	if (!(flags&HASWIDTH))
-		*flagp &= ~HASWIDTH;
-	*flagp |= flags&SPSTART;
-	while (*preg->regparse == '|') {
-		preg->regparse++;
-		br = regbranch(preg, &flags);
-		if (br == 0)
-			return 0;
-		regtail(preg, ret, br);
-		if (!(flags&HASWIDTH))
-			*flagp &= ~HASWIDTH;
-		*flagp |= flags&SPSTART;
-	}
-
-
-	ender = regnode(preg, (paren) ? CLOSE+parno : END);
-	regtail(preg, ret, ender);
-
-
-	for (br = ret; br != 0; br = regnext(preg, br))
-		regoptail(preg, br, ender);
-
-
-	if (paren && *preg->regparse++ != ')') {
-		preg->err = REG_ERR_UNMATCHED_PAREN;
-		return 0;
-	} else if (!paren && *preg->regparse != '\0') {
-		if (*preg->regparse == ')') {
-			preg->err = REG_ERR_UNMATCHED_PAREN;
-			return 0;
-		} else {
-			preg->err = REG_ERR_JUNK_ON_END;
-			return 0;
-		}
-	}
-
-	return(ret);
-}
-
-static int regbranch(regex_t *preg, int *flagp )
-{
-	int ret;
-	int chain;
-	int latest;
-	int flags;
-
-	*flagp = WORST;
-
-	ret = regnode(preg, BRANCH);
-	chain = 0;
-	while (*preg->regparse != '\0' && *preg->regparse != ')' &&
-	       *preg->regparse != '|') {
-		latest = regpiece(preg, &flags);
-		if (latest == 0)
-			return 0;
-		*flagp |= flags&HASWIDTH;
-		if (chain == 0) {
-			*flagp |= flags&SPSTART;
-		}
-		else {
-			regtail(preg, chain, latest);
-		}
-		chain = latest;
-	}
-	if (chain == 0)
-		(void) regnode(preg, NOTHING);
-
-	return(ret);
-}
-
-static int regpiece(regex_t *preg, int *flagp)
-{
-	int ret;
-	char op;
-	int next;
-	int flags;
-	int min;
-	int max;
-
-	ret = regatom(preg, &flags);
-	if (ret == 0)
-		return 0;
-
-	op = *preg->regparse;
-	if (!ISMULT(op)) {
-		*flagp = flags;
-		return(ret);
-	}
-
-	if (!(flags&HASWIDTH) && op != '?') {
-		preg->err = REG_ERR_OPERAND_COULD_BE_EMPTY;
-		return 0;
-	}
-
-
-	if (op == '{') {
-		char *end;
-
-		min = strtoul(preg->regparse + 1, &end, 10);
-		if (end == preg->regparse + 1) {
-			preg->err = REG_ERR_BAD_COUNT;
-			return 0;
-		}
-		if (*end == '}') {
-			max = min;
-		}
-		else if (*end == '\0') {
-			preg->err = REG_ERR_UNMATCHED_BRACES;
-			return 0;
-		}
-		else {
-			preg->regparse = end;
-			max = strtoul(preg->regparse + 1, &end, 10);
-			if (*end != '}') {
-				preg->err = REG_ERR_UNMATCHED_BRACES;
-				return 0;
-			}
-		}
-		if (end == preg->regparse + 1) {
-			max = MAX_REP_COUNT;
-		}
-		else if (max < min || max >= 100) {
-			preg->err = REG_ERR_BAD_COUNT;
-			return 0;
-		}
-		if (min >= 100) {
-			preg->err = REG_ERR_BAD_COUNT;
-			return 0;
-		}
-
-		preg->regparse = strchr(preg->regparse, '}');
-	}
-	else {
-		min = (op == '+');
-		max = (op == '?' ? 1 : MAX_REP_COUNT);
-	}
-
-	if (preg->regparse[1] == '?') {
-		preg->regparse++;
-		next = reginsert(preg, flags & SIMPLE ? REPMIN : REPXMIN, 5, ret);
-	}
-	else {
-		next = reginsert(preg, flags & SIMPLE ? REP: REPX, 5, ret);
-	}
-	preg->program[ret + 2] = max;
-	preg->program[ret + 3] = min;
-	preg->program[ret + 4] = 0;
-
-	*flagp = (min) ? (WORST|HASWIDTH) : (WORST|SPSTART);
-
-	if (!(flags & SIMPLE)) {
-		int back = regnode(preg, BACK);
-		regtail(preg, back, ret);
-		regtail(preg, next, back);
-	}
-
-	preg->regparse++;
-	if (ISMULT(*preg->regparse)) {
-		preg->err = REG_ERR_NESTED_COUNT;
-		return 0;
-	}
-
-	return ret;
-}
-
-static void reg_addrange(regex_t *preg, int lower, int upper)
-{
-	if (lower > upper) {
-		reg_addrange(preg, upper, lower);
-	}
-
-	regc(preg, upper - lower + 1);
-	regc(preg, lower);
-}
-
-static void reg_addrange_str(regex_t *preg, const char *str)
-{
-	while (*str) {
-		reg_addrange(preg, *str, *str);
-		str++;
-	}
-}
-
-static int reg_utf8_tounicode_case(const char *s, int *uc, int upper)
-{
-	int l = utf8_tounicode(s, uc);
-	if (upper) {
-		*uc = utf8_upper(*uc);
-	}
-	return l;
-}
-
-static int hexdigitval(int c)
-{
-	if (c >= '0' && c <= '9')
-		return c - '0';
-	if (c >= 'a' && c <= 'f')
-		return c - 'a' + 10;
-	if (c >= 'A' && c <= 'F')
-		return c - 'A' + 10;
-	return -1;
-}
-
-static int parse_hex(const char *s, int n, int *uc)
-{
-	int val = 0;
-	int k;
-
-	for (k = 0; k < n; k++) {
-		int c = hexdigitval(*s++);
-		if (c == -1) {
-			break;
-		}
-		val = (val << 4) | c;
-	}
-	if (k) {
-		*uc = val;
-	}
-	return k;
-}
-
-static int reg_decode_escape(const char *s, int *ch)
-{
-	int n;
-	const char *s0 = s;
-
-	*ch = *s++;
-
-	switch (*ch) {
-		case 'b': *ch = '\b'; break;
-		case 'e': *ch = 27; break;
-		case 'f': *ch = '\f'; break;
-		case 'n': *ch = '\n'; break;
-		case 'r': *ch = '\r'; break;
-		case 't': *ch = '\t'; break;
-		case 'v': *ch = '\v'; break;
-		case 'u':
-			if (*s == '{') {
-
-				n = parse_hex(s + 1, 6, ch);
-				if (n > 0 && s[n + 1] == '}' && *ch >= 0 && *ch <= 0x1fffff) {
-					s += n + 2;
-				}
-				else {
-
-					*ch = 'u';
-				}
-			}
-			else if ((n = parse_hex(s, 4, ch)) > 0) {
-				s += n;
-			}
-			break;
-		case 'U':
-			if ((n = parse_hex(s, 8, ch)) > 0) {
-				s += n;
-			}
-			break;
-		case 'x':
-			if ((n = parse_hex(s, 2, ch)) > 0) {
-				s += n;
-			}
-			break;
-		case '\0':
-			s--;
-			*ch = '\\';
-			break;
-	}
-	return s - s0;
-}
-
-static int regatom(regex_t *preg, int *flagp)
-{
-	int ret;
-	int flags;
-	int nocase = (preg->cflags & REG_ICASE);
-
-	int ch;
-	int n = reg_utf8_tounicode_case(preg->regparse, &ch, nocase);
-
-	*flagp = WORST;
-
-	preg->regparse += n;
-	switch (ch) {
-
-	case '^':
-		ret = regnode(preg, BOL);
-		break;
-	case '$':
-		ret = regnode(preg, EOL);
-		break;
-	case '.':
-		ret = regnode(preg, ANY);
-		*flagp |= HASWIDTH|SIMPLE;
-		break;
-	case '[': {
-			const char *pattern = preg->regparse;
-
-			if (*pattern == '^') {
-				ret = regnode(preg, ANYBUT);
-				pattern++;
-			} else
-				ret = regnode(preg, ANYOF);
-
-
-			if (*pattern == ']' || *pattern == '-') {
-				reg_addrange(preg, *pattern, *pattern);
-				pattern++;
-			}
-
-			while (*pattern != ']') {
-
-				int start;
-				int end;
-
-				enum {
-					CC_ALPHA, CC_ALNUM, CC_SPACE, CC_BLANK, CC_UPPER, CC_LOWER,
-					CC_DIGIT, CC_XDIGIT, CC_CNTRL, CC_GRAPH, CC_PRINT, CC_PUNCT,
-					CC_NUM
-				};
-				int cc;
-
-				if (!*pattern) {
-					preg->err = REG_ERR_UNMATCHED_BRACKET;
-					return 0;
-				}
-
-				pattern += reg_utf8_tounicode_case(pattern, &start, nocase);
-				if (start == '\\') {
-
-					switch (*pattern) {
-						case 's':
-							pattern++;
-							cc = CC_SPACE;
-							goto cc_switch;
-						case 'd':
-							pattern++;
-							cc = CC_DIGIT;
-							goto cc_switch;
-						case 'w':
-							pattern++;
-							reg_addrange(preg, '_', '_');
-							cc = CC_ALNUM;
-							goto cc_switch;
-					}
-					pattern += reg_decode_escape(pattern, &start);
-					if (start == 0) {
-						preg->err = REG_ERR_NULL_CHAR;
-						return 0;
-					}
-					if (start == '\\' && *pattern == 0) {
-						preg->err = REG_ERR_INVALID_ESCAPE;
-						return 0;
-					}
-				}
-				if (pattern[0] == '-' && pattern[1] && pattern[1] != ']') {
-
-					pattern += utf8_tounicode(pattern, &end);
-					pattern += reg_utf8_tounicode_case(pattern, &end, nocase);
-					if (end == '\\') {
-						pattern += reg_decode_escape(pattern, &end);
-						if (end == 0) {
-							preg->err = REG_ERR_NULL_CHAR;
-							return 0;
-						}
-						if (end == '\\' && *pattern == 0) {
-							preg->err = REG_ERR_INVALID_ESCAPE;
-							return 0;
-						}
-					}
-
-					reg_addrange(preg, start, end);
-					continue;
-				}
-				if (start == '[' && pattern[0] == ':') {
-					static const char *character_class[] = {
-						":alpha:", ":alnum:", ":space:", ":blank:", ":upper:", ":lower:",
-						":digit:", ":xdigit:", ":cntrl:", ":graph:", ":print:", ":punct:",
-					};
-
-					for (cc = 0; cc < CC_NUM; cc++) {
-						n = strlen(character_class[cc]);
-						if (strncmp(pattern, character_class[cc], n) == 0) {
-							if (pattern[n] != ']') {
-								preg->err = REG_ERR_UNMATCHED_BRACKET;
-								return 0;
-							}
-
-							pattern += n + 1;
-							break;
-						}
-					}
-					if (cc != CC_NUM) {
-cc_switch:
-						switch (cc) {
-							case CC_ALNUM:
-								reg_addrange(preg, '0', '9');
-
-							case CC_ALPHA:
-								if ((preg->cflags & REG_ICASE) == 0) {
-									reg_addrange(preg, 'a', 'z');
-								}
-								reg_addrange(preg, 'A', 'Z');
-								break;
-							case CC_SPACE:
-								reg_addrange_str(preg, " \t\r\n\f\v");
-								break;
-							case CC_BLANK:
-								reg_addrange_str(preg, " \t");
-								break;
-							case CC_UPPER:
-								reg_addrange(preg, 'A', 'Z');
-								break;
-							case CC_LOWER:
-								reg_addrange(preg, 'a', 'z');
-								break;
-							case CC_XDIGIT:
-								reg_addrange(preg, 'a', 'f');
-								reg_addrange(preg, 'A', 'F');
-
-							case CC_DIGIT:
-								reg_addrange(preg, '0', '9');
-								break;
-							case CC_CNTRL:
-								reg_addrange(preg, 0, 31);
-								reg_addrange(preg, 127, 127);
-								break;
-							case CC_PRINT:
-								reg_addrange(preg, ' ', '~');
-								break;
-							case CC_GRAPH:
-								reg_addrange(preg, '!', '~');
-								break;
-							case CC_PUNCT:
-								reg_addrange(preg, '!', '/');
-								reg_addrange(preg, ':', '@');
-								reg_addrange(preg, '[', '`');
-								reg_addrange(preg, '{', '~');
-								break;
-						}
-						continue;
-					}
-				}
-
-				reg_addrange(preg, start, start);
-			}
-			regc(preg, '\0');
-
-			if (*pattern) {
-				pattern++;
-			}
-			preg->regparse = pattern;
-
-			*flagp |= HASWIDTH|SIMPLE;
-		}
-		break;
-	case '(':
-		ret = reg(preg, 1, &flags);
-		if (ret == 0)
-			return 0;
-		*flagp |= flags&(HASWIDTH|SPSTART);
-		break;
-	case '\0':
-	case '|':
-	case ')':
-		preg->err = REG_ERR_INTERNAL;
-		return 0;
-	case '?':
-	case '+':
-	case '*':
-	case '{':
-		preg->err = REG_ERR_COUNT_FOLLOWS_NOTHING;
-		return 0;
-	case '\\':
-		ch = *preg->regparse++;
-		switch (ch) {
-		case '\0':
-			preg->err = REG_ERR_INVALID_ESCAPE;
-			return 0;
-		case 'A':
-			ret = regnode(preg, BOLX);
-			break;
-		case 'Z':
-			ret = regnode(preg, EOLX);
-			break;
-		case '<':
-		case 'm':
-			ret = regnode(preg, WORDA);
-			break;
-		case '>':
-		case 'M':
-			ret = regnode(preg, WORDZ);
-			break;
-		case 'd':
-		case 'D':
-			ret = regnode(preg, ch == 'd' ? ANYOF : ANYBUT);
-			reg_addrange(preg, '0', '9');
-			regc(preg, '\0');
-			*flagp |= HASWIDTH|SIMPLE;
-			break;
-		case 'w':
-		case 'W':
-			ret = regnode(preg, ch == 'w' ? ANYOF : ANYBUT);
-			if ((preg->cflags & REG_ICASE) == 0) {
-				reg_addrange(preg, 'a', 'z');
-			}
-			reg_addrange(preg, 'A', 'Z');
-			reg_addrange(preg, '0', '9');
-			reg_addrange(preg, '_', '_');
-			regc(preg, '\0');
-			*flagp |= HASWIDTH|SIMPLE;
-			break;
-		case 's':
-		case 'S':
-			ret = regnode(preg, ch == 's' ? ANYOF : ANYBUT);
-			reg_addrange_str(preg," \t\r\n\f\v");
-			regc(preg, '\0');
-			*flagp |= HASWIDTH|SIMPLE;
-			break;
-
-		default:
-
-
-			preg->regparse--;
-			goto de_fault;
-		}
-		break;
-	de_fault:
-	default: {
-			int added = 0;
-
-
-			preg->regparse -= n;
-
-			ret = regnode(preg, EXACTLY);
-
-
-
-			while (*preg->regparse && strchr(META, *preg->regparse) == NULL) {
-				n = reg_utf8_tounicode_case(preg->regparse, &ch, (preg->cflags & REG_ICASE));
-				if (ch == '\\' && preg->regparse[n]) {
-					if (strchr("<>mMwWdDsSAZ", preg->regparse[n])) {
-
-						break;
-					}
-					n += reg_decode_escape(preg->regparse + n, &ch);
-					if (ch == 0) {
-						preg->err = REG_ERR_NULL_CHAR;
-						return 0;
-					}
-				}
-
-
-				if (ISMULT(preg->regparse[n])) {
-
-					if (added) {
-
-						break;
-					}
-
-					regc(preg, ch);
-					added++;
-					preg->regparse += n;
-					break;
-				}
-
-
-				regc(preg, ch);
-				added++;
-				preg->regparse += n;
-			}
-			regc(preg, '\0');
-
-			*flagp |= HASWIDTH;
-			if (added == 1)
-				*flagp |= SIMPLE;
-			break;
-		}
-		break;
-	}
-
-	return(ret);
-}
-
-static void reg_grow(regex_t *preg, int n)
-{
-	if (preg->p + n >= preg->proglen) {
-		preg->proglen = (preg->p + n) * 2;
-		preg->program = realloc(preg->program, preg->proglen * sizeof(int));
-	}
-}
-
-
-static int regnode(regex_t *preg, int op)
-{
-	reg_grow(preg, 2);
-
-
-	preg->program[preg->p++] = op;
-	preg->program[preg->p++] = 0;
-
-
-	return preg->p - 2;
-}
-
-static void regc(regex_t *preg, int b )
-{
-	reg_grow(preg, 1);
-	preg->program[preg->p++] = b;
-}
-
-static int reginsert(regex_t *preg, int op, int size, int opnd )
-{
-	reg_grow(preg, size);
-
-
-	memmove(preg->program + opnd + size, preg->program + opnd, sizeof(int) * (preg->p - opnd));
-
-	memset(preg->program + opnd, 0, sizeof(int) * size);
-
-	preg->program[opnd] = op;
-
-	preg->p += size;
-
-	return opnd + size;
-}
-
-static void regtail(regex_t *preg, int p, int val)
-{
-	int scan;
-	int temp;
-	int offset;
-
-
-	scan = p;
-	for (;;) {
-		temp = regnext(preg, scan);
-		if (temp == 0)
-			break;
-		scan = temp;
-	}
-
-	if (OP(preg, scan) == BACK)
-		offset = scan - val;
-	else
-		offset = val - scan;
-
-	preg->program[scan + 1] = offset;
-}
-
-
-static void regoptail(regex_t *preg, int p, int val )
-{
-
-	if (p != 0 && OP(preg, p) == BRANCH) {
-		regtail(preg, OPERAND(p), val);
-	}
-}
-
-
-static int regtry(regex_t *preg, const char *string );
-static int regmatch(regex_t *preg, int prog);
-static int regrepeat(regex_t *preg, int p, int max);
-
-int jim_regexec(regex_t  *preg,  const  char *string, size_t nmatch, regmatch_t pmatch[], int eflags)
-{
-	const char *s;
-	int scan;
-
-
-	if (preg == NULL || preg->program == NULL || string == NULL) {
-		return REG_ERR_NULL_ARGUMENT;
-	}
-
-
-	if (*preg->program != REG_MAGIC) {
-		return REG_ERR_CORRUPTED;
-	}
-
-#ifdef DEBUG
-	fprintf(stderr, "regexec: %s\n", string);
-	regdump(preg);
-#endif
-
-	preg->eflags = eflags;
-	preg->pmatch = pmatch;
-	preg->nmatch = nmatch;
-	preg->start = string;
-
-
-	for (scan = OPERAND(1); scan != 0; scan += regopsize(preg, scan)) {
-		int op = OP(preg, scan);
-		if (op == END)
-			break;
-		if (op == REPX || op == REPXMIN)
-			preg->program[scan + 4] = 0;
-	}
-
-
-	if (preg->regmust != 0) {
-		s = string;
-		while ((s = str_find(s, preg->program[preg->regmust], preg->cflags & REG_ICASE)) != NULL) {
-			if (prefix_cmp(preg->program + preg->regmust, preg->regmlen, s, preg->cflags & REG_ICASE) >= 0) {
-				break;
-			}
-			s++;
-		}
-		if (s == NULL)
-			return REG_NOMATCH;
-	}
-
-
-	preg->regbol = string;
-
-
-	if (preg->reganch) {
-		if (eflags & REG_NOTBOL) {
-
-			goto nextline;
-		}
-		while (1) {
-			if (regtry(preg, string)) {
-				return REG_NOERROR;
-			}
-			if (*string) {
-nextline:
-				if (preg->cflags & REG_NEWLINE) {
-
-					string = strchr(string, '\n');
-					if (string) {
-						preg->regbol = ++string;
-						continue;
-					}
-				}
-			}
-			return REG_NOMATCH;
-		}
-	}
-
-
-	s = string;
-	if (preg->regstart != '\0') {
-
-		while ((s = str_find(s, preg->regstart, preg->cflags & REG_ICASE)) != NULL) {
-			if (regtry(preg, s))
-				return REG_NOERROR;
-			s++;
-		}
-	}
-	else
-
-		while (1) {
-			if (regtry(preg, s))
-				return REG_NOERROR;
-			if (*s == '\0') {
-				break;
-			}
-			else {
-				int c;
-				s += utf8_tounicode(s, &c);
-			}
-		}
-
-
-	return REG_NOMATCH;
-}
-
-
-static int regtry( regex_t *preg, const char *string )
-{
-	int i;
-
-	preg->reginput = string;
-
-	for (i = 0; i < preg->nmatch; i++) {
-		preg->pmatch[i].rm_so = -1;
-		preg->pmatch[i].rm_eo = -1;
-	}
-	if (regmatch(preg, 1)) {
-		preg->pmatch[0].rm_so = string - preg->start;
-		preg->pmatch[0].rm_eo = preg->reginput - preg->start;
-		return(1);
-	} else
-		return(0);
-}
-
-static int prefix_cmp(const int *prog, int proglen, const char *string, int nocase)
-{
-	const char *s = string;
-	while (proglen && *s) {
-		int ch;
-		int n = reg_utf8_tounicode_case(s, &ch, nocase);
-		if (ch != *prog) {
-			return -1;
-		}
-		prog++;
-		s += n;
-		proglen--;
-	}
-	if (proglen == 0) {
-		return s - string;
-	}
-	return -1;
-}
-
-static int reg_range_find(const int *range, int c)
-{
-	while (*range) {
-
-		if (c >= range[1] && c <= (range[0] + range[1] - 1)) {
-			return 1;
-		}
-		range += 2;
-	}
-	return 0;
-}
-
-static const char *str_find(const char *string, int c, int nocase)
-{
-	if (nocase) {
-
-		c = utf8_upper(c);
-	}
-	while (*string) {
-		int ch;
-		int n = reg_utf8_tounicode_case(string, &ch, nocase);
-		if (c == ch) {
-			return string;
-		}
-		string += n;
-	}
-	return NULL;
-}
-
-static int reg_iseol(regex_t *preg, int ch)
-{
-	if (preg->cflags & REG_NEWLINE) {
-		return ch == '\0' || ch == '\n';
-	}
-	else {
-		return ch == '\0';
-	}
-}
-
-static int regmatchsimplerepeat(regex_t *preg, int scan, int matchmin)
-{
-	int nextch = '\0';
-	const char *save;
-	int no;
-	int c;
-
-	int max = preg->program[scan + 2];
-	int min = preg->program[scan + 3];
-	int next = regnext(preg, scan);
-
-	if (OP(preg, next) == EXACTLY) {
-		nextch = preg->program[OPERAND(next)];
-	}
-	save = preg->reginput;
-	no = regrepeat(preg, scan + 5, max);
-	if (no < min) {
-		return 0;
-	}
-	if (matchmin) {
-
-		max = no;
-		no = min;
-	}
-
-	while (1) {
-		if (matchmin) {
-			if (no > max) {
-				break;
-			}
-		}
-		else {
-			if (no < min) {
-				break;
-			}
-		}
-		preg->reginput = save + utf8_index(save, no);
-		reg_utf8_tounicode_case(preg->reginput, &c, (preg->cflags & REG_ICASE));
-
-		if (reg_iseol(preg, nextch) || c == nextch) {
-			if (regmatch(preg, next)) {
-				return(1);
-			}
-		}
-		if (matchmin) {
-
-			no++;
-		}
-		else {
-
-			no--;
-		}
-	}
-	return(0);
-}
-
-static int regmatchrepeat(regex_t *preg, int scan, int matchmin)
-{
-	int *scanpt = preg->program + scan;
-
-	int max = scanpt[2];
-	int min = scanpt[3];
-
-
-	if (scanpt[4] < min) {
-
-		scanpt[4]++;
-		if (regmatch(preg, scan + 5)) {
-			return 1;
-		}
-		scanpt[4]--;
-		return 0;
-	}
-	if (scanpt[4] > max) {
-		return 0;
-	}
-
-	if (matchmin) {
-
-		if (regmatch(preg, regnext(preg, scan))) {
-			return 1;
-		}
-
-		scanpt[4]++;
-		if (regmatch(preg, scan + 5)) {
-			return 1;
-		}
-		scanpt[4]--;
-		return 0;
-	}
-
-	if (scanpt[4] < max) {
-		scanpt[4]++;
-		if (regmatch(preg, scan + 5)) {
-			return 1;
-		}
-		scanpt[4]--;
-	}
-
-	return regmatch(preg, regnext(preg, scan));
-}
-
-
-static int regmatch(regex_t *preg, int prog)
-{
-	int scan;
-	int next;
-	const char *save;
-
-	scan = prog;
-
-#ifdef DEBUG
-	if (scan != 0 && regnarrate)
-		fprintf(stderr, "%s(\n", regprop(scan));
-#endif
-	while (scan != 0) {
-		int n;
-		int c;
-#ifdef DEBUG
-		if (regnarrate) {
-			fprintf(stderr, "%3d: %s...\n", scan, regprop(OP(preg, scan)));
-		}
-#endif
-		next = regnext(preg, scan);
-		n = reg_utf8_tounicode_case(preg->reginput, &c, (preg->cflags & REG_ICASE));
-
-		switch (OP(preg, scan)) {
-		case BOLX:
-			if ((preg->eflags & REG_NOTBOL)) {
-				return(0);
-			}
-
-		case BOL:
-			if (preg->reginput != preg->regbol) {
-				return(0);
-			}
-			break;
-		case EOLX:
-			if (c != 0) {
-
-				return 0;
-			}
-			break;
-		case EOL:
-			if (!reg_iseol(preg, c)) {
-				return(0);
-			}
-			break;
-		case WORDA:
-
-			if ((!isalnum(UCHAR(c))) && c != '_')
-				return(0);
-
-			if (preg->reginput > preg->regbol &&
-				(isalnum(UCHAR(preg->reginput[-1])) || preg->reginput[-1] == '_'))
-				return(0);
-			break;
-		case WORDZ:
-
-			if (preg->reginput > preg->regbol) {
-
-				if (reg_iseol(preg, c) || !(isalnum(UCHAR(c)) || c == '_')) {
-					c = preg->reginput[-1];
-
-					if (isalnum(UCHAR(c)) || c == '_') {
-						break;
-					}
-				}
-			}
-
-			return(0);
-
-		case ANY:
-			if (reg_iseol(preg, c))
-				return 0;
-			preg->reginput += n;
-			break;
-		case EXACTLY: {
-				int opnd;
-				int len;
-				int slen;
-
-				opnd = OPERAND(scan);
-				len = str_int_len(preg->program + opnd);
-
-				slen = prefix_cmp(preg->program + opnd, len, preg->reginput, preg->cflags & REG_ICASE);
-				if (slen < 0) {
-					return(0);
-				}
-				preg->reginput += slen;
-			}
-			break;
-		case ANYOF:
-			if (reg_iseol(preg, c) || reg_range_find(preg->program + OPERAND(scan), c) == 0) {
-				return(0);
-			}
-			preg->reginput += n;
-			break;
-		case ANYBUT:
-			if (reg_iseol(preg, c) || reg_range_find(preg->program + OPERAND(scan), c) != 0) {
-				return(0);
-			}
-			preg->reginput += n;
-			break;
-		case NOTHING:
-			break;
-		case BACK:
-			break;
-		case BRANCH:
-			if (OP(preg, next) != BRANCH)
-				next = OPERAND(scan);
-			else {
-				do {
-					save = preg->reginput;
-					if (regmatch(preg, OPERAND(scan))) {
-						return(1);
-					}
-					preg->reginput = save;
-					scan = regnext(preg, scan);
-				} while (scan != 0 && OP(preg, scan) == BRANCH);
-				return(0);
-
-			}
-			break;
-		case REP:
-		case REPMIN:
-			return regmatchsimplerepeat(preg, scan, OP(preg, scan) == REPMIN);
-
-		case REPX:
-		case REPXMIN:
-			return regmatchrepeat(preg, scan, OP(preg, scan) == REPXMIN);
-
-		case END:
-			return 1;
-
-		case OPENNC:
-		case CLOSENC:
-			return regmatch(preg, next);
-
-		default:
-			if (OP(preg, scan) >= OPEN+1 && OP(preg, scan) < CLOSE_END) {
-				save = preg->reginput;
-				if (regmatch(preg, next)) {
-					if (OP(preg, scan) < CLOSE) {
-						int no = OP(preg, scan) - OPEN;
-						if (no < preg->nmatch && preg->pmatch[no].rm_so == -1) {
-							preg->pmatch[no].rm_so = save - preg->start;
-						}
-					}
-					else {
-						int no = OP(preg, scan) - CLOSE;
-						if (no < preg->nmatch && preg->pmatch[no].rm_eo == -1) {
-							preg->pmatch[no].rm_eo = save - preg->start;
-						}
-					}
-					return(1);
-				}
-
-				preg->reginput = save;
-				return(0);
-			}
-			return REG_ERR_INTERNAL;
-		}
-
-		scan = next;
-	}
-
-	return REG_ERR_INTERNAL;
-}
-
-static int regrepeat(regex_t *preg, int p, int max)
-{
-	int count = 0;
-	const char *scan;
-	int opnd;
-	int ch;
-	int n;
-
-	scan = preg->reginput;
-	opnd = OPERAND(p);
-	switch (OP(preg, p)) {
-	case ANY:
-		while (!reg_iseol(preg, *scan) && count < max) {
-			count++;
-			scan += utf8_charlen(*scan);
-		}
-		break;
-	case EXACTLY:
-		while (count < max) {
-			n = reg_utf8_tounicode_case(scan, &ch, preg->cflags & REG_ICASE);
-			if (preg->program[opnd] != ch) {
-				break;
-			}
-			count++;
-			scan += n;
-		}
-		break;
-	case ANYOF:
-		while (count < max) {
-			n = reg_utf8_tounicode_case(scan, &ch, preg->cflags & REG_ICASE);
-			if (reg_iseol(preg, ch) || reg_range_find(preg->program + opnd, ch) == 0) {
-				break;
-			}
-			count++;
-			scan += n;
-		}
-		break;
-	case ANYBUT:
-		while (count < max) {
-			n = reg_utf8_tounicode_case(scan, &ch, preg->cflags & REG_ICASE);
-			if (reg_iseol(preg, ch) || reg_range_find(preg->program + opnd, ch) != 0) {
-				break;
-			}
-			count++;
-			scan += n;
-		}
-		break;
-	default:
-		preg->err = REG_ERR_INTERNAL;
-		count = 0;
-		break;
-	}
-	preg->reginput = scan;
-
-	return(count);
-}
-
-static int regnext(regex_t *preg, int p )
-{
-	int offset;
-
-	offset = NEXT(preg, p);
-
-	if (offset == 0)
-		return 0;
-
-	if (OP(preg, p) == BACK)
-		return(p-offset);
-	else
-		return(p+offset);
-}
-
-static int regopsize(regex_t *preg, int p )
-{
-
-	switch (OP(preg, p)) {
-		case REP:
-		case REPMIN:
-		case REPX:
-		case REPXMIN:
-			return 5;
-
-		case ANYOF:
-		case ANYBUT:
-		case EXACTLY: {
-			int s = p + 2;
-			while (preg->program[s++]) {
-			}
-			return s - p;
-		}
-	}
-	return 2;
-}
-
-
-size_t jim_regerror(int errcode, const regex_t *preg, char *errbuf,  size_t errbuf_size)
-{
-	static const char *error_strings[] = {
-		"success",
-		"no match",
-		"bad pattern",
-		"null argument",
-		"unknown error",
-		"too big",
-		"out of memory",
-		"too many ()",
-		"parentheses () not balanced",
-		"braces {} not balanced",
-		"invalid repetition count(s)",
-		"extra characters",
-		"*+ of empty atom",
-		"nested count",
-		"internal error",
-		"count follows nothing",
-		"invalid escape \\ sequence",
-		"corrupted program",
-		"contains null char",
-		"brackets [] not balanced",
-	};
-	const char *err;
-
-	if (errcode < 0 || errcode >= REG_ERR_NUM) {
-		err = "Bad error code";
-	}
-	else {
-		err = error_strings[errcode];
-	}
-
-	return snprintf(errbuf, errbuf_size, "%s", err);
-}
-
-void jim_regfree(regex_t *preg)
-{
-	free(preg->program);
-}
-
-#endif
-#include <string.h>
-
-void Jim_SetResultErrno(Jim_Interp *interp, const char *msg)
-{
-    Jim_SetResultFormatted(interp, "%s: %s", msg, strerror(Jim_Errno()));
-}
-
-#if defined(_WIN32) || defined(WIN32)
-#include <sys/stat.h>
-
-int Jim_Errno(void)
-{
-    switch (GetLastError()) {
-    case ERROR_FILE_NOT_FOUND: return ENOENT;
-    case ERROR_PATH_NOT_FOUND: return ENOENT;
-    case ERROR_TOO_MANY_OPEN_FILES: return EMFILE;
-    case ERROR_ACCESS_DENIED: return EACCES;
-    case ERROR_INVALID_HANDLE: return EBADF;
-    case ERROR_BAD_ENVIRONMENT: return E2BIG;
-    case ERROR_BAD_FORMAT: return ENOEXEC;
-    case ERROR_INVALID_ACCESS: return EACCES;
-    case ERROR_INVALID_DRIVE: return ENOENT;
-    case ERROR_CURRENT_DIRECTORY: return EACCES;
-    case ERROR_NOT_SAME_DEVICE: return EXDEV;
-    case ERROR_NO_MORE_FILES: return ENOENT;
-    case ERROR_WRITE_PROTECT: return EROFS;
-    case ERROR_BAD_UNIT: return ENXIO;
-    case ERROR_NOT_READY: return EBUSY;
-    case ERROR_BAD_COMMAND: return EIO;
-    case ERROR_CRC: return EIO;
-    case ERROR_BAD_LENGTH: return EIO;
-    case ERROR_SEEK: return EIO;
-    case ERROR_WRITE_FAULT: return EIO;
-    case ERROR_READ_FAULT: return EIO;
-    case ERROR_GEN_FAILURE: return EIO;
-    case ERROR_SHARING_VIOLATION: return EACCES;
-    case ERROR_LOCK_VIOLATION: return EACCES;
-    case ERROR_SHARING_BUFFER_EXCEEDED: return ENFILE;
-    case ERROR_HANDLE_DISK_FULL: return ENOSPC;
-    case ERROR_NOT_SUPPORTED: return ENODEV;
-    case ERROR_REM_NOT_LIST: return EBUSY;
-    case ERROR_DUP_NAME: return EEXIST;
-    case ERROR_BAD_NETPATH: return ENOENT;
-    case ERROR_NETWORK_BUSY: return EBUSY;
-    case ERROR_DEV_NOT_EXIST: return ENODEV;
-    case ERROR_TOO_MANY_CMDS: return EAGAIN;
-    case ERROR_ADAP_HDW_ERR: return EIO;
-    case ERROR_BAD_NET_RESP: return EIO;
-    case ERROR_UNEXP_NET_ERR: return EIO;
-    case ERROR_NETNAME_DELETED: return ENOENT;
-    case ERROR_NETWORK_ACCESS_DENIED: return EACCES;
-    case ERROR_BAD_DEV_TYPE: return ENODEV;
-    case ERROR_BAD_NET_NAME: return ENOENT;
-    case ERROR_TOO_MANY_NAMES: return ENFILE;
-    case ERROR_TOO_MANY_SESS: return EIO;
-    case ERROR_SHARING_PAUSED: return EAGAIN;
-    case ERROR_REDIR_PAUSED: return EAGAIN;
-    case ERROR_FILE_EXISTS: return EEXIST;
-    case ERROR_CANNOT_MAKE: return ENOSPC;
-    case ERROR_OUT_OF_STRUCTURES: return ENFILE;
-    case ERROR_ALREADY_ASSIGNED: return EEXIST;
-    case ERROR_INVALID_PASSWORD: return EPERM;
-    case ERROR_NET_WRITE_FAULT: return EIO;
-    case ERROR_NO_PROC_SLOTS: return EAGAIN;
-    case ERROR_DISK_CHANGE: return EXDEV;
-    case ERROR_BROKEN_PIPE: return EPIPE;
-    case ERROR_OPEN_FAILED: return ENOENT;
-    case ERROR_DISK_FULL: return ENOSPC;
-    case ERROR_NO_MORE_SEARCH_HANDLES: return EMFILE;
-    case ERROR_INVALID_TARGET_HANDLE: return EBADF;
-    case ERROR_INVALID_NAME: return ENOENT;
-    case ERROR_PROC_NOT_FOUND: return ESRCH;
-    case ERROR_WAIT_NO_CHILDREN: return ECHILD;
-    case ERROR_CHILD_NOT_COMPLETE: return ECHILD;
-    case ERROR_DIRECT_ACCESS_HANDLE: return EBADF;
-    case ERROR_SEEK_ON_DEVICE: return ESPIPE;
-    case ERROR_BUSY_DRIVE: return EAGAIN;
-    case ERROR_DIR_NOT_EMPTY: return EEXIST;
-    case ERROR_NOT_LOCKED: return EACCES;
-    case ERROR_BAD_PATHNAME: return ENOENT;
-    case ERROR_LOCK_FAILED: return EACCES;
-    case ERROR_ALREADY_EXISTS: return EEXIST;
-    case ERROR_FILENAME_EXCED_RANGE: return ENAMETOOLONG;
-    case ERROR_BAD_PIPE: return EPIPE;
-    case ERROR_PIPE_BUSY: return EAGAIN;
-    case ERROR_PIPE_NOT_CONNECTED: return EPIPE;
-    case ERROR_DIRECTORY: return ENOTDIR;
-    }
-    return EINVAL;
-}
-
-long JimProcessPid(phandle_t pid)
-{
-    if (pid == INVALID_HANDLE_VALUE) {
-        return -1;
-    }
-    return GetProcessId(pid);
-}
-
-phandle_t JimWaitPid(long pid, int *status, int nohang)
-{
-    if (pid > 0) {
-        HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION | SYNCHRONIZE, FALSE, pid);
-        if (h) {
-            long pid = waitpid(h, status, nohang);
-            CloseHandle(h);
-            if (pid > 0) {
-                return h;
-            }
-        }
-    }
-    return JIM_BAD_PHANDLE;
-}
-
-long waitpid(phandle_t phandle, int *status, int nohang)
-{
-    long pid;
-    DWORD ret = WaitForSingleObject(phandle, nohang ? 0 : INFINITE);
-    if (ret == WAIT_TIMEOUT || ret == WAIT_FAILED) {
-
-        return -1;
-    }
-    GetExitCodeProcess(phandle, &ret);
-    *status = ret;
-
-    pid = GetProcessId(phandle);
-    CloseHandle(phandle);
-    return pid;
-}
-
-int Jim_MakeTempFile(Jim_Interp *interp, const char *filename_template, int unlink_file)
-{
-    char name[MAX_PATH];
-    HANDLE handle;
-
-    if (!GetTempPath(MAX_PATH, name) || !GetTempFileName(name, filename_template ? filename_template : "JIM", 0, name)) {
-        return -1;
-    }
-
-    handle = CreateFile(name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
-            CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY | (unlink_file ? FILE_FLAG_DELETE_ON_CLOSE : 0),
-            NULL);
-
-    if (handle == INVALID_HANDLE_VALUE) {
-        goto error;
-    }
-
-    Jim_SetResultString(interp, name, -1);
-    return _open_osfhandle((intptr_t)handle, _O_RDWR | _O_TEXT);
-
-  error:
-    Jim_SetResultErrno(interp, name);
-    DeleteFile(name);
-    return -1;
-}
-
-int Jim_OpenForWrite(const char *filename, int append)
-{
-    if (strcmp(filename, "/dev/null") == 0) {
-        filename = "nul:";
-    }
-    int fd = _open(filename, _O_WRONLY | _O_CREAT | _O_TEXT | (append ? _O_APPEND : _O_TRUNC), _S_IREAD | _S_IWRITE);
-    if (fd >= 0 && append) {
-
-        _lseek(fd, 0L, SEEK_END);
-    }
-    return fd;
-}
-
-int Jim_OpenForRead(const char *filename)
-{
-    if (strcmp(filename, "/dev/null") == 0) {
-        filename = "nul:";
-    }
-    return _open(filename, _O_RDONLY | _O_TEXT, 0);
-}
-
-#elif defined(HAVE_UNISTD_H)
-
-
-
-int Jim_MakeTempFile(Jim_Interp *interp, const char *filename_template, int unlink_file)
-{
-    int fd;
-    mode_t mask;
-    Jim_Obj *filenameObj;
-
-    if (filename_template == NULL) {
-        const char *tmpdir = getenv("TMPDIR");
-        if (tmpdir == NULL || *tmpdir == '\0' || access(tmpdir, W_OK) != 0) {
-            tmpdir = "/tmp/";
-        }
-        filenameObj = Jim_NewStringObj(interp, tmpdir, -1);
-        if (tmpdir[0] && tmpdir[strlen(tmpdir) - 1] != '/') {
-            Jim_AppendString(interp, filenameObj, "/", 1);
-        }
-        Jim_AppendString(interp, filenameObj, "tcl.tmp.XXXXXX", -1);
-    }
-    else {
-        filenameObj = Jim_NewStringObj(interp, filename_template, -1);
-    }
-
-
-#ifdef HAVE_UMASK
-    mask = umask(S_IXUSR | S_IRWXG | S_IRWXO);
-#endif
-#ifdef HAVE_MKSTEMP
-    fd = mkstemp(filenameObj->bytes);
-#else
-    if (mktemp(filenameObj->bytes) == NULL) {
-        fd = -1;
-    }
-    else {
-        fd = open(filenameObj->bytes, O_RDWR | O_CREAT | O_TRUNC);
-    }
-#endif
-#ifdef HAVE_UMASK
-    umask(mask);
-#endif
-    if (fd < 0) {
-        Jim_SetResultErrno(interp, Jim_String(filenameObj));
-        Jim_FreeNewObj(interp, filenameObj);
-        return -1;
-    }
-    if (unlink_file) {
-        remove(Jim_String(filenameObj));
-    }
-
-    Jim_SetResult(interp, filenameObj);
-    return fd;
-}
-
-int Jim_OpenForWrite(const char *filename, int append)
-{
-    return open(filename, O_WRONLY | O_CREAT | (append ? O_APPEND : O_TRUNC), 0666);
-}
-
-int Jim_OpenForRead(const char *filename)
-{
-    return open(filename, O_RDONLY, 0);
-}
-
-#endif
-
-#if defined(_WIN32) || defined(WIN32)
-#ifndef STRICT
-#define STRICT
-#endif
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-
-#if defined(HAVE_DLOPEN_COMPAT)
-void *dlopen(const char *path, int mode)
-{
-    JIM_NOTUSED(mode);
-
-    return (void *)LoadLibraryA(path);
-}
-
-int dlclose(void *handle)
-{
-    FreeLibrary((HANDLE)handle);
-    return 0;
-}
-
-void *dlsym(void *handle, const char *symbol)
-{
-    return GetProcAddress((HMODULE)handle, symbol);
-}
-
-char *dlerror(void)
-{
-    static char msg[121];
-    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
-                   LANG_NEUTRAL, msg, sizeof(msg) - 1, NULL);
-    return msg;
-}
-#endif
-
-#ifdef _MSC_VER
-
-#include <sys/timeb.h>
-
-
-int gettimeofday(struct timeval *tv, void *unused)
-{
-    struct _timeb tb;
-
-    _ftime(&tb);
-    tv->tv_sec = tb.time;
-    tv->tv_usec = tb.millitm * 1000;
-
-    return 0;
-}
-
-
-DIR *opendir(const char *name)
-{
-    DIR *dir = 0;
-
-    if (name && name[0]) {
-        size_t base_length = strlen(name);
-        const char *all =
-            strchr("/\\", name[base_length - 1]) ? "*" : "/*";
-
-        if ((dir = (DIR *) Jim_Alloc(sizeof *dir)) != 0 &&
-            (dir->name = (char *)Jim_Alloc(base_length + strlen(all) + 1)) != 0) {
-            strcat(strcpy(dir->name, name), all);
-
-            if ((dir->handle = (long)_findfirst(dir->name, &dir->info)) != -1)
-                dir->result.d_name = 0;
-            else {
-                Jim_Free(dir->name);
-                Jim_Free(dir);
-                dir = 0;
-            }
-        }
-        else {
-            Jim_Free(dir);
-            dir = 0;
-            errno = ENOMEM;
-        }
-    }
-    else {
-        errno = EINVAL;
-    }
-    return dir;
-}
-
-int closedir(DIR * dir)
-{
-    int result = -1;
-
-    if (dir) {
-        if (dir->handle != -1)
-            result = _findclose(dir->handle);
-        Jim_Free(dir->name);
-        Jim_Free(dir);
-    }
-    if (result == -1)
-        errno = EBADF;
-    return result;
-}
-
-struct dirent *readdir(DIR * dir)
-{
-    struct dirent *result = 0;
-
-    if (dir && dir->handle != -1) {
-        if (!dir->result.d_name || _findnext(dir->handle, &dir->info) != -1) {
-            result = &dir->result;
-            result->d_name = dir->info.name;
-        }
-    }
-    else {
-        errno = EBADF;
-    }
-    return result;
-}
-#endif
-#endif
-#include <stdio.h>
-#include <signal.h>
-
-
-
-
-
-
-#ifndef SIGPIPE
-#define SIGPIPE 13
-#endif
-#ifndef SIGINT
-#define SIGINT 2
-#endif
-
-const char *Jim_SignalId(int sig)
-{
-	static char buf[10];
-	switch (sig) {
-		case SIGINT: return "SIGINT";
-		case SIGPIPE: return "SIGPIPE";
-
-	}
-	snprintf(buf, sizeof(buf), "%d", sig);
-	return buf;
-}
-#ifndef JIM_BOOTSTRAP_LIB_ONLY
-#include <errno.h>
-#include <string.h>
-#include <stdio.h>
-
-
-#ifdef USE_LINENOISE
-#ifdef HAVE_UNISTD_H
-    #include <unistd.h>
-#endif
-#ifdef HAVE_SYS_STAT_H
-    #include <sys/stat.h>
-#endif
-#include "linenoise.h"
-#else
-#define MAX_LINE_LEN 512
-#endif
-
-#ifdef USE_LINENOISE
-struct JimCompletionInfo {
-    Jim_Interp *interp;
-    Jim_Obj *completion_command;
-    Jim_Obj *hints_command;
-
-};
-
-static struct JimCompletionInfo *JimGetCompletionInfo(Jim_Interp *interp);
-static void JimCompletionCallback(const char *prefix, linenoiseCompletions *comp, void *userdata);
-static const char completion_callback_assoc_key[] = "interactive-completion";
-static char *JimHintsCallback(const char *prefix, int *color, int *bold, void *userdata);
-static void JimFreeHintsCallback(void *hint, void *userdata);
-#endif
-
-char *Jim_HistoryGetline(Jim_Interp *interp, const char *prompt)
-{
-#ifdef USE_LINENOISE
-    struct JimCompletionInfo *compinfo = JimGetCompletionInfo(interp);
-    char *result;
-    Jim_Obj *objPtr;
-    long mlmode = 0;
-    if (compinfo->completion_command) {
-        linenoiseSetCompletionCallback(JimCompletionCallback, compinfo);
-    }
-    if (compinfo->hints_command) {
-        linenoiseSetHintsCallback(JimHintsCallback, compinfo);
-        linenoiseSetFreeHintsCallback(JimFreeHintsCallback);
-    }
-    objPtr = Jim_GetVariableStr(interp, "history::multiline", JIM_NONE);
-    if (objPtr && Jim_GetLong(interp, objPtr, &mlmode) == JIM_NONE) {
-        linenoiseSetMultiLine(mlmode);
-    }
-
-    result = linenoise(prompt);
-
-    linenoiseSetCompletionCallback(NULL, NULL);
-    linenoiseSetHintsCallback(NULL, NULL);
-    linenoiseSetFreeHintsCallback(NULL);
-    return result;
-#else
-    int len;
-    char *line = Jim_Alloc(MAX_LINE_LEN);
-
-    fputs(prompt, stdout);
-    fflush(stdout);
-
-    if (fgets(line, MAX_LINE_LEN, stdin) == NULL) {
-        Jim_Free(line);
-        return NULL;
-    }
-    len = strlen(line);
-    if (len && line[len - 1] == '\n') {
-        line[len - 1] = '\0';
-    }
-    return line;
-#endif
-}
-
-void Jim_HistoryLoad(const char *filename)
-{
-#ifdef USE_LINENOISE
-    linenoiseHistoryLoad(filename);
-#endif
-}
-
-void Jim_HistoryAdd(const char *line)
-{
-#ifdef USE_LINENOISE
-    linenoiseHistoryAdd(line);
-#endif
-}
-
-void Jim_HistorySave(const char *filename)
-{
-#ifdef USE_LINENOISE
-#ifdef HAVE_UMASK
-    mode_t mask;
-
-    mask = umask(S_IXUSR | S_IRWXG | S_IRWXO);
-#endif
-    linenoiseHistorySave(filename);
-#ifdef HAVE_UMASK
-    umask(mask);
-#endif
-#endif
-}
-
-void Jim_HistoryShow(void)
-{
-#ifdef USE_LINENOISE
-
-    int i;
-    int len;
-    char **history = linenoiseHistory(&len);
-    for (i = 0; i < len; i++) {
-        printf("%4d %s\n", i + 1, history[i]);
-    }
-#endif
-}
-
-void Jim_HistorySetMaxLen(int length)
-{
-#ifdef USE_LINENOISE
-    linenoiseHistorySetMaxLen(length);
-#endif
-}
-
-int Jim_HistoryGetMaxLen(void)
-{
-#ifdef USE_LINENOISE
-    return linenoiseHistoryGetMaxLen();
-#endif
-    return 0;
-}
-
-#ifdef USE_LINENOISE
-static void JimCompletionCallback(const char *prefix, linenoiseCompletions *comp, void *userdata)
-{
-    struct JimCompletionInfo *info = (struct JimCompletionInfo *)userdata;
-    Jim_Obj *objv[2];
-    int ret;
-
-    objv[0] = info->completion_command;
-    objv[1] = Jim_NewStringObj(info->interp, prefix, -1);
-
-    ret = Jim_EvalObjVector(info->interp, 2, objv);
-
-
-    if (ret == JIM_OK) {
-        int i;
-        Jim_Obj *listObj = Jim_GetResult(info->interp);
-        int len = Jim_ListLength(info->interp, listObj);
-        for (i = 0; i < len; i++) {
-            linenoiseAddCompletion(comp, Jim_String(Jim_ListGetIndex(info->interp, listObj, i)));
-        }
-    }
-}
-
-static char *JimHintsCallback(const char *prefix, int *color, int *bold, void *userdata)
-{
-    struct JimCompletionInfo *info = (struct JimCompletionInfo *)userdata;
-    Jim_Obj *objv[2];
-    int ret;
-    char *result = NULL;
-
-    objv[0] = info->hints_command;
-    objv[1] = Jim_NewStringObj(info->interp, prefix, -1);
-
-    ret = Jim_EvalObjVector(info->interp, 2, objv);
-
-
-    if (ret == JIM_OK) {
-        Jim_Obj *listObj = Jim_GetResult(info->interp);
-        Jim_IncrRefCount(listObj);
-
-        int len = Jim_ListLength(info->interp, listObj);
-        if (len >= 1) {
-            long x;
-            result = Jim_StrDup(Jim_String(Jim_ListGetIndex(info->interp, listObj, 0)));
-            if (len >= 2 && Jim_GetLong(info->interp, Jim_ListGetIndex(info->interp, listObj, 1), &x) == JIM_OK) {
-                *color = x;
-            }
-            if (len >= 3 && Jim_GetLong(info->interp, Jim_ListGetIndex(info->interp, listObj, 2), &x) == JIM_OK) {
-                *bold = x;
-            }
-        }
-        Jim_DecrRefCount(info->interp, listObj);
-    }
-    return result;
-}
-
-static void JimFreeHintsCallback(void *hint, void *userdata)
-{
-    Jim_Free(hint);
-}
-
-static void JimHistoryFreeCompletion(Jim_Interp *interp, void *data)
-{
-    struct JimCompletionInfo *compinfo = data;
-
-    if (compinfo->completion_command) {
-        Jim_DecrRefCount(interp, compinfo->completion_command);
-    }
-    if (compinfo->hints_command) {
-        Jim_DecrRefCount(interp, compinfo->hints_command);
-    }
-
-    Jim_Free(compinfo);
-}
-
-static struct JimCompletionInfo *JimGetCompletionInfo(Jim_Interp *interp)
-{
-    struct JimCompletionInfo *compinfo = Jim_GetAssocData(interp, completion_callback_assoc_key);
-    if (compinfo == NULL) {
-        compinfo = Jim_Alloc(sizeof(*compinfo));
-        compinfo->interp = interp;
-        compinfo->completion_command = NULL;
-        compinfo->hints_command = NULL;
-        Jim_SetAssocData(interp, completion_callback_assoc_key, JimHistoryFreeCompletion, compinfo);
-    }
-    return compinfo;
-}
-#endif
-
-void Jim_HistorySetCompletion(Jim_Interp *interp, Jim_Obj *completionCommandObj)
-{
-#ifdef USE_LINENOISE
-    struct JimCompletionInfo *compinfo = JimGetCompletionInfo(interp);
-
-    if (completionCommandObj) {
-
-        Jim_IncrRefCount(completionCommandObj);
-    }
-    if (compinfo->completion_command) {
-        Jim_DecrRefCount(interp, compinfo->completion_command);
-    }
-    compinfo->completion_command = completionCommandObj;
-#endif
-}
-
-void Jim_HistorySetHints(Jim_Interp *interp, Jim_Obj *hintsCommandObj)
-{
-#ifdef USE_LINENOISE
-    struct JimCompletionInfo *compinfo = JimGetCompletionInfo(interp);
-
-    if (hintsCommandObj) {
-
-        Jim_IncrRefCount(hintsCommandObj);
-    }
-    if (compinfo->hints_command) {
-        Jim_DecrRefCount(interp, compinfo->hints_command);
-    }
-    compinfo->hints_command = hintsCommandObj;
-#endif
-}
-
-int Jim_InteractivePrompt(Jim_Interp *interp)
-{
-    int retcode = JIM_OK;
-    char *history_file = NULL;
-#ifdef USE_LINENOISE
-    const char *home;
-
-    home = getenv("HOME");
-    if (home && isatty(STDIN_FILENO)) {
-        int history_len = strlen(home) + sizeof("/.jim_history");
-        history_file = Jim_Alloc(history_len);
-        snprintf(history_file, history_len, "%s/.jim_history", home);
-        Jim_HistoryLoad(history_file);
-    }
-
-    Jim_HistorySetCompletion(interp, Jim_NewStringObj(interp, "tcl::autocomplete", -1));
-    Jim_HistorySetHints(interp, Jim_NewStringObj(interp, "tcl::stdhint", -1));
-#endif
-
-    printf("Welcome to Jim version %d.%d\n",
-        JIM_VERSION / 100, JIM_VERSION % 100);
-    Jim_SetVariableStrWithStr(interp, JIM_INTERACTIVE, "1");
-
-    while (1) {
-        Jim_Obj *scriptObjPtr;
-        const char *result;
-        int reslen;
-        char prompt[20];
-
-        if (retcode != JIM_OK) {
-            const char *retcodestr = Jim_ReturnCode(retcode);
-
-            if (*retcodestr == '?') {
-                snprintf(prompt, sizeof(prompt) - 3, "[%d] . ", retcode);
-            }
-            else {
-                snprintf(prompt, sizeof(prompt) - 3, "[%s] . ", retcodestr);
-            }
-        }
-        else {
-            strcpy(prompt, ". ");
-        }
-
-        scriptObjPtr = Jim_NewStringObj(interp, "", 0);
-        Jim_IncrRefCount(scriptObjPtr);
-        while (1) {
-            char state;
-            char *line;
-
-            line = Jim_HistoryGetline(interp, prompt);
-            if (line == NULL) {
-                if (errno == EINTR) {
-                    continue;
-                }
-                Jim_DecrRefCount(interp, scriptObjPtr);
-                retcode = JIM_OK;
-                goto out;
-            }
-            if (Jim_Length(scriptObjPtr) != 0) {
-
-                Jim_AppendString(interp, scriptObjPtr, "\n", 1);
-            }
-            Jim_AppendString(interp, scriptObjPtr, line, -1);
-            Jim_Free(line);
-            if (Jim_ScriptIsComplete(interp, scriptObjPtr, &state))
-                break;
-
-            snprintf(prompt, sizeof(prompt), "%c> ", state);
-        }
-#ifdef USE_LINENOISE
-        if (strcmp(Jim_String(scriptObjPtr), "h") == 0) {
-
-            Jim_HistoryShow();
-            Jim_DecrRefCount(interp, scriptObjPtr);
-            continue;
-        }
-
-        Jim_HistoryAdd(Jim_String(scriptObjPtr));
-        if (history_file) {
-            Jim_HistorySave(history_file);
-        }
-#endif
-        retcode = Jim_EvalObj(interp, scriptObjPtr);
-        Jim_DecrRefCount(interp, scriptObjPtr);
-
-        if (retcode == JIM_EXIT) {
-            break;
-        }
-        if (retcode == JIM_ERR) {
-            Jim_MakeErrorMessage(interp);
-        }
-        result = Jim_GetString(Jim_GetResult(interp), &reslen);
-        if (reslen) {
-            if (fwrite(result, reslen, 1, stdout) == 0) {
-
-            }
-            putchar('\n');
-        }
-    }
-  out:
-    Jim_Free(history_file);
-
-    return retcode;
-}
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-
-extern int Jim_initjimshInit(Jim_Interp *interp);
-
-static void JimSetArgv(Jim_Interp *interp, int argc, char *const argv[])
-{
-    int n;
-    Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
-
-
-    for (n = 0; n < argc; n++) {
-        Jim_Obj *obj = Jim_NewStringObj(interp, argv[n], -1);
-
-        Jim_ListAppendElement(interp, listObj, obj);
-    }
-
-    Jim_SetVariableStr(interp, "argv", listObj);
-    Jim_SetVariableStr(interp, "argc", Jim_NewIntObj(interp, argc));
-}
-
-static void JimPrintErrorMessage(Jim_Interp *interp)
-{
-    Jim_MakeErrorMessage(interp);
-    fprintf(stderr, "%s\n", Jim_String(Jim_GetResult(interp)));
-}
-
-void usage(const char* executable_name)
-{
-    printf("jimsh version %d.%d\n", JIM_VERSION / 100, JIM_VERSION % 100);
-    printf("Usage: %s\n", executable_name);
-    printf("or   : %s [options] [filename]\n", executable_name);
-    printf("\n");
-    printf("Without options: Interactive mode\n");
-    printf("\n");
-    printf("Options:\n");
-    printf("      --version  : prints the version string\n");
-    printf("      --help     : prints this text\n");
-    printf("      -e CMD     : executes command CMD\n");
-    printf("                   NOTE: all subsequent options will be passed as arguments to the command\n");
-    printf("    [filename|-] : executes the script contained in the named file, or from stdin if \"-\"\n");
-    printf("                   NOTE: all subsequent options will be passed to the script\n\n");
-}
-
-int main(int argc, char *const argv[])
-{
-    int retcode;
-    Jim_Interp *interp;
-    char *const orig_argv0 = argv[0];
-
-
-    if (argc > 1 && strcmp(argv[1], "--version") == 0) {
-        printf("%d.%d\n", JIM_VERSION / 100, JIM_VERSION % 100);
-        return 0;
-    }
-    else if (argc > 1 && strcmp(argv[1], "--help") == 0) {
-        usage(argv[0]);
-        return 0;
-    }
-
-
-    interp = Jim_CreateInterp();
-    Jim_RegisterCoreCommands(interp);
-
-
-    if (Jim_InitStaticExtensions(interp) != JIM_OK) {
-        JimPrintErrorMessage(interp);
-    }
-
-    Jim_SetVariableStrWithStr(interp, "jim::argv0", orig_argv0);
-    Jim_SetVariableStrWithStr(interp, JIM_INTERACTIVE, argc == 1 ? "1" : "0");
-#ifdef USE_LINENOISE
-    Jim_SetVariableStrWithStr(interp, "jim::lineedit", "1");
-#else
-    Jim_SetVariableStrWithStr(interp, "jim::lineedit", "0");
-#endif
-    retcode = Jim_initjimshInit(interp);
-
-    if (argc == 1) {
-
-        if (retcode == JIM_ERR) {
-            JimPrintErrorMessage(interp);
-        }
-        if (retcode != JIM_EXIT) {
-            JimSetArgv(interp, 0, NULL);
-            if (!isatty(STDIN_FILENO)) {
-
-                goto eval_stdin;
-            }
-            retcode = Jim_InteractivePrompt(interp);
-        }
-    }
-    else {
-
-        if (argc > 2 && strcmp(argv[1], "-e") == 0) {
-
-            JimSetArgv(interp, argc - 3, argv + 3);
-            retcode = Jim_Eval(interp, argv[2]);
-            if (retcode != JIM_ERR) {
-                int len;
-                const char *msg = Jim_GetString(Jim_GetResult(interp), &len);
-                if (fwrite(msg, len, 1, stdout) == 0) {
-
-                }
-                putchar('\n');
-            }
-        }
-        else {
-            Jim_SetVariableStr(interp, "argv0", Jim_NewStringObj(interp, argv[1], -1));
-            JimSetArgv(interp, argc - 2, argv + 2);
-            if (strcmp(argv[1], "-") == 0) {
-eval_stdin:
-                retcode = Jim_Eval(interp, "eval [info source [stdin read] stdin 1]");
-            } else {
-                retcode = Jim_EvalFile(interp, argv[1]);
-            }
-        }
-        if (retcode == JIM_ERR) {
-            JimPrintErrorMessage(interp);
-        }
-    }
-    if (retcode == JIM_EXIT) {
-        retcode = Jim_GetExitCode(interp);
-    }
-    else if (retcode == JIM_ERR) {
-        retcode = 1;
-    }
-    else {
-        retcode = 0;
-    }
-    Jim_FreeInterp(interp);
-    return retcode;
-}
-#endif
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/pkg-config.tcl b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/pkg-config.tcl
deleted file mode 100644
index 9ce7111..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/pkg-config.tcl
+++ /dev/null
@@ -1,168 +0,0 @@
-# Copyright (c) 2016 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# @synopsis:
-#
-# The 'pkg-config' module allows package information to be found via 'pkg-config'.
-#
-# If not cross-compiling, the package path should be determined automatically
-# by 'pkg-config'.
-# If cross-compiling, the default package path is the compiler sysroot.
-# If the C compiler doesn't support '-print-sysroot', the path can be supplied
-# by the '--sysroot' option or by defining 'SYSROOT'.
-#
-# 'PKG_CONFIG' may be set to use an alternative to 'pkg-config'.
-
-use cc
-
-options {
-	sysroot:dir => "Override compiler sysroot for pkg-config search path"
-}
-
-# @pkg-config-init ?required?
-#
-# Initialises the 'pkg-config' system. Unless '$required' is set to 0,
-# it is a fatal error if a usable 'pkg-config' is not found .
-#
-# This command will normally be called automatically as required,
-# but it may be invoked explicitly if lack of 'pkg-config' is acceptable.
-#
-# Returns 1 if ok, or 0 if 'pkg-config' not found/usable (only if '$required' is 0).
-#
-proc pkg-config-init {{required 1}} {
-	if {[is-defined HAVE_PKG_CONFIG]} {
-		return [get-define HAVE_PKG_CONFIG]
-	}
-	set found 0
-
-	define PKG_CONFIG [get-env PKG_CONFIG pkg-config]
-	msg-checking "Checking for pkg-config..."
-
-	if {[catch {exec [get-define PKG_CONFIG] --version} version]} {
-		msg-result "[get-define PKG_CONFIG] (not found)"
-		if {$required} {
-			user-error "No usable pkg-config"
-		}
-	} else {
-		msg-result $version
-		define PKG_CONFIG_VERSION $version
-
-		set found 1
-
-		if {[opt-str sysroot o]} {
-			define SYSROOT [file-normalize $o]
-			msg-result "Using specified sysroot [get-define SYSROOT]"
-		} elseif {[get-define build] ne [get-define host]} {
-			if {[catch {exec-with-stderr {*}[get-define CC] -print-sysroot} result errinfo] == 0} {
-				# Use the compiler sysroot, if there is one
-				define SYSROOT $result
-				msg-result "Found compiler sysroot $result"
-			} else {
-				configlog "[get-define CC] -print-sysroot: $result"
-				set msg "pkg-config: Cross compiling, but no compiler sysroot and no --sysroot supplied"
-				if {$required} {
-					user-error $msg
-				} else {
-					msg-result $msg
-				}
-				set found 0
-			}
-		}
-		if {[is-defined SYSROOT]} {
-			set sysroot [get-define SYSROOT]
-
-			# XXX: It's possible that these should be set only when invoking pkg-config
-			global env
-			set env(PKG_CONFIG_DIR) ""
-			# Supposedly setting PKG_CONFIG_LIBDIR means that PKG_CONFIG_PATH is ignored,
-			# but it doesn't seem to work that way in practice
-			set env(PKG_CONFIG_PATH) ""
-			# Do we need to try /usr/local as well or instead?
-			set env(PKG_CONFIG_LIBDIR) $sysroot/usr/lib/pkgconfig:$sysroot/usr/share/pkgconfig
-			set env(PKG_CONFIG_SYSROOT_DIR) $sysroot
-		}
-	}
-	define HAVE_PKG_CONFIG $found
-	return $found
-}
-
-# @pkg-config module ?requirements?
-#
-# Use 'pkg-config' to find the given module meeting the given requirements.
-# e.g.
-#
-## pkg-config pango >= 1.37.0
-#
-# If found, returns 1 and sets 'HAVE_PKG_PANGO' to 1 along with:
-#
-## PKG_PANGO_VERSION to the found version
-## PKG_PANGO_LIBS    to the required libs (--libs-only-l)
-## PKG_PANGO_LDFLAGS to the required linker flags (--libs-only-L)
-## PKG_PANGO_CFLAGS  to the required compiler flags (--cflags)
-#
-# If not found, returns 0.
-#
-proc pkg-config {module args} {
-	set ok [pkg-config-init]
-
-	msg-checking "Checking for $module $args..."
-
-	if {!$ok} {
-		msg-result "no pkg-config"
-		return 0
-	}
-
-	set pkgconfig [get-define PKG_CONFIG]
-
-	set ret [catch {exec $pkgconfig --modversion "$module $args"} version]
-	configlog "$pkgconfig --modversion $module $args: $version"
-	if {$ret} {
-		msg-result "not found"
-		return 0
-	}
-	# Sometimes --modversion succeeds but because of dependencies it isn't usable
-	# This seems to show up with --cflags
-	set ret [catch {exec $pkgconfig --cflags $module} cflags]
-	if {$ret} {
-		msg-result "unusable ($version - see config.log)"
-		configlog "$pkgconfig --cflags $module"
-		configlog $cflags
-		return 0
-	}
-	msg-result $version
-	set prefix [feature-define-name $module PKG_]
-	define HAVE_${prefix}
-	define ${prefix}_VERSION $version
-	define ${prefix}_CFLAGS $cflags
-	define ${prefix}_LIBS [exec $pkgconfig --libs-only-l $module]
-	define ${prefix}_LDFLAGS [exec $pkgconfig --libs-only-L $module]
-	return 1
-}
-
-# @pkg-config-get module setting
-#
-# Convenience access to the results of 'pkg-config'.
-#
-# For example, '[pkg-config-get pango CFLAGS]' returns
-# the value of 'PKG_PANGO_CFLAGS', or '""' if not defined.
-proc pkg-config-get {module name} {
-	set prefix [feature-define-name $module PKG_]
-	get-define ${prefix}_${name} ""
-}
-
-# @pkg-config-get-var module variable
-#
-# Return the value of the given variable from the given pkg-config module.
-# The module must already have been successfully detected with pkg-config.
-# e.g.
-#
-## if {[pkg-config harfbuzz >= 2.5]} {
-##   define harfbuzz_libdir [pkg-config-get-var harfbuzz libdir]
-## }
-#
-# Returns the empty string if the variable isn't defined.
-proc pkg-config-get-var {module variable} {
-	set pkgconfig [get-define PKG_CONFIG]
-	set prefix [feature-define-name $module HAVE_PKG_]
-	exec $pkgconfig $module --variable $variable
-}
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/proj.tcl b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/proj.tcl
deleted file mode 100644
index caa679a..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/proj.tcl
+++ /dev/null
@@ -1,2549 +0,0 @@
-########################################################################
-# 2024 September 25
-#
-# The author disclaims copyright to this source code.  In place of
-# a legal notice, here is a blessing:
-#
-#  * May you do good and not evil.
-#  * May you find forgiveness for yourself and forgive others.
-#  * May you share freely, never taking more than you give.
-#
-
-#
-# ----- @module proj.tcl -----
-# @section Project-agnostic Helper APIs
-#
-
-#
-# Routines for Steve Bennett's autosetup which are common to trees
-# managed in and around the umbrella of the SQLite project.
-#
-# The intent is that these routines be relatively generic, independent
-# of a given project.
-#
-# For practical purposes, the copy of this file hosted in the SQLite
-# project is the "canonical" one:
-#
-# https://sqlite.org/src/file/autosetup/proj.tcl
-#
-# This file was initially derived from one used in the libfossil
-# project, authored by the same person who ported it here, and this is
-# noted here only as an indication that there are no licensing issues
-# despite this code having a handful of near-twins running around a
-# handful of third-party source trees.
-#
-# Design notes:
-#
-# - Symbols with _ separators are intended for internal use within
-#   this file, and are not part of the API which auto.def files should
-#   rely on. Symbols with - separators are public APIs.
-#
-# - By and large, autosetup prefers to update global state with the
-#   results of feature checks, e.g. whether the compiler supports flag
-#   --X.  In this developer's opinion that (A) causes more confusion
-#   than it solves[^1] and (B) adds an unnecessary layer of "voodoo"
-#   between the autosetup user and its internals. This module, in
-#   contrast, instead injects the results of its own tests into
-#   well-defined variables and leaves the integration of those values
-#   to the caller's discretion.
-#
-# [1]: As an example: testing for the -rpath flag, using
-# cc-check-flags, can break later checks which use
-# [cc-check-function-in-lib ...] because the resulting -rpath flag
-# implicitly becomes part of those tests. In the case of an rpath
-# test, downstream tests may not like the $prefix/lib path added by
-# the rpath test. To avoid such problems, we avoid (intentionally)
-# updating global state via feature tests.
-#
-
-#
-# $proj__Config is an internal-use-only array for storing whatever generic
-# internal stuff we need stored.
-#
-array set ::proj__Config [subst {
-  self-tests [get-env proj.self-tests 0]
-  verbose-assert [get-env proj.assert-verbose 0]
-  isatty [isatty? stdout]
-}]
-
-#
-# List of dot-in files to filter in the final stages of
-# configuration. Some configuration steps may append to this.  Each
-# one in this list which exists will trigger the generation of a
-# file with that same name, minus the ".in", in the build directory
-# (which differ from the source dir in out-of-tree builds).
-#
-# See: proj-dot-ins-append and proj-dot-ins-process
-#
-set ::proj__Config(dot-in-files) [list]
-
-#
-# @proj-warn msg
-#
-# Emits a warning message to stderr. All args are appended with a
-# space between each.
-#
-proc proj-warn {args} {
-  show-notices
-  puts stderr [join [list "WARNING:" \[ [proj-scope 1] \]: {*}$args] " "]
-}
-
-
-#
-# Internal impl of [proj-fatal] and [proj-error]. It must be called
-# using tailcall.
-#
-proc proj__faterr {failMode args} {
-  show-notices
-  set lvl 1
-  while {"-up" eq [lindex $args 0]} {
-    set args [lassign $args -]
-    incr lvl
-  }
-  if {$failMode} {
-    puts stderr [join [list "FATAL:" \[ [proj-scope $lvl] \]: {*}$args]]
-    exit 1
-  } else {
-    error [join [list in \[ [proj-scope $lvl] \]: {*}$args]]
-  }
-}
-
-#
-# @proj-fatal ?-up...? msg...
-#
-# Emits an error message to stderr and exits with non-0. All args are
-# appended with a space between each.
-#
-# The calling scope's name is used in the error message. To instead
-# use the name of a call higher up in the stack, use -up once for each
-# additional level.
-#
-proc proj-fatal {args} {
-  tailcall proj__faterr 1 {*}$args
-}
-
-#
-# @proj-error ?-up...? msg...
-#
-# Works like proj-fatal but uses [error] intead of [exit].
-#
-proc proj-error {args} {
-  tailcall proj__faterr 0 {*}$args
-}
-
-#
-# @proj-assert script ?message?
-#
-# Kind of like a C assert: if uplevel of [list expr $script] is false,
-# a fatal error is triggered. The error message, by default, includes
-# the body of the failed assertion, but if $msg is set then that is
-# used instead.
-#
-proc proj-assert {script {msg ""}} {
-  if {1 eq $::proj__Config(verbose-assert)} {
-    msg-result [proj-bold "asserting: $script"]
-  }
-  if {![uplevel 1 [list expr $script]]} {
-    if {"" eq $msg} {
-      set msg $script
-    }
-    tailcall proj__faterr 1 "Assertion failed:" $msg
-  }
-}
-
-#
-# @proj-bold str
-#
-# If this function believes that the current console might support
-# ANSI escape sequences then this returns $str wrapped in a sequence
-# to bold that text, else it returns $str as-is.
-#
-proc proj-bold {args} {
-  if {$::autosetup(iswin) || !$::proj__Config(isatty)} {
-    return [join $args]
-  }
-  return "\033\[1m${args}\033\[0m"
-}
-
-#
-# @proj-indented-notice ?-error? ?-notice? msg
-#
-# Takes a multi-line message and emits it with consistent indentation.
-# It does not perform any line-wrapping of its own. Which output
-# routine it uses depends on its flags, defaulting to msg-result.
-# For -error and -notice it uses user-notice.
-#
-# If the -notice flag it used then it emits using [user-notice], which
-# means its rendering will (A) go to stderr and (B) be delayed until
-# the next time autosetup goes to output a message.
-#
-# If the -error flag is provided then it renders the message
-# immediately to stderr and then exits.
-#
-# If neither -notice nor -error are used, the message will be sent to
-# stdout without delay.
-#
-proc proj-indented-notice {args} {
-  set fErr ""
-  set outFunc "msg-result"
-  while {[llength $args] > 1} {
-    switch -exact -- [lindex $args 0] {
-      -error  {
-        set args [lassign $args fErr]
-        set outFunc "user-notice"
-      }
-      -notice {
-        set args [lassign $args -]
-        set outFunc "user-notice"
-      }
-      default {
-        break
-      }
-    }
-  }
-  set lines [split [join $args] \n]
-  foreach line $lines {
-    set line [string trimleft $line]
-    if {"" eq $line} {
-      $outFunc $line
-    } else {
-      $outFunc "    $line"
-    }
-  }
-  if {"" ne $fErr} {
-    show-notices
-    exit 1
-  }
-}
-
-#
-# @proj-is-cross-compiling
-#
-# Returns 1 if cross-compiling, else 0.
-#
-proc proj-is-cross-compiling {} {
-  expr {[get-define host] ne [get-define build]}
-}
-
-#
-# @proj-strip-hash-comments value
-#
-# Expects to receive string input, which it splits on newlines, strips
-# out any lines which begin with any number of whitespace followed by
-# a '#', and returns a value containing the [append]ed results of each
-# remaining line with a \n between each. It does not strip out
-# comments which appear after the first non-whitespace character.
-#
-proc proj-strip-hash-comments {val} {
-  set x {}
-  foreach line [split $val \n] {
-    if {![string match "#*" [string trimleft $line]]} {
-      append x $line \n
-    }
-  }
-  return $x
-}
-
-#
-# @proj-cflags-without-werror
-#
-# Fetches [define $var], strips out any -Werror entries, and returns
-# the new value. This is intended for temporarily stripping -Werror
-# from CFLAGS or CPPFLAGS within the scope of a [define-push] block.
-#
-proc proj-cflags-without-werror {{var CFLAGS}} {
-  set rv {}
-  foreach f [get-define $var ""] {
-    switch -exact -- $f {
-      -Werror {}
-      default { lappend rv $f }
-    }
-  }
-  join $rv " "
-}
-
-#
-# @proj-check-function-in-lib
-#
-# A proxy for cc-check-function-in-lib with the following differences:
-#
-# - Does not make any global changes to the LIBS define.
-#
-# - Strips out the -Werror flag from CFLAGS before running the test,
-#   as these feature tests will often fail if -Werror is used.
-#
-# Returns the result of cc-check-function-in-lib (i.e. true or false).
-# The resulting linker flags are stored in the [define] named
-# lib_${function}.
-#
-proc proj-check-function-in-lib {function libs {otherlibs {}}} {
-  set found 0
-  define-push {LIBS CFLAGS} {
-    #puts "CFLAGS before=[get-define CFLAGS]"
-    define CFLAGS [proj-cflags-without-werror]
-    #puts "CFLAGS after =[get-define CFLAGS]"
-    set found [cc-check-function-in-lib $function $libs $otherlibs]
-  }
-  return $found
-}
-
-#
-# @proj-search-for-header-dir ?-dirs LIST? ?-subdirs LIST? header
-#
-# Searches for $header in a combination of dirs and subdirs, specified
-# by the -dirs {LIST} and -subdirs {LIST} flags (each of which have
-# sane defaults). Returns either the first matching dir or an empty
-# string.  The return value does not contain the filename part.
-#
-proc proj-search-for-header-dir {header args} {
-  set subdirs {include}
-  set dirs {/usr /usr/local /mingw}
-# Debatable:
-#  if {![proj-is-cross-compiling]} {
-#    lappend dirs [get-define prefix]
-#  }
-  while {[llength $args]} {
-    switch -exact -- [lindex $args 0] {
-      -dirs     { set args [lassign $args - dirs] }
-      -subdirs  { set args [lassign $args - subdirs] }
-      default   {
-        proj-error "Unhandled argument: $args"
-      }
-    }
-  }
-  foreach dir $dirs {
-    foreach sub $subdirs {
-      if {[file exists $dir/$sub/$header]} {
-        return "$dir/$sub"
-      }
-    }
-  }
-  return ""
-}
-
-#
-# @proj-find-executable-path ?-v? binaryName
-#
-# Works similarly to autosetup's [find-executable-path $binName] but:
-#
-# - If the first arg is -v, it's verbose about searching, else it's quiet.
-#
-# Returns the full path to the result or an empty string.
-#
-proc proj-find-executable-path {args} {
-  set binName $args
-  set verbose 0
-  if {[lindex $args 0] eq "-v"} {
-    set verbose 1
-    set args [lassign $args - binName]
-    msg-checking "Looking for $binName ... "
-  }
-  set check [find-executable-path $binName]
-  if {$verbose} {
-    if {"" eq $check} {
-      msg-result "not found"
-    } else {
-      msg-result $check
-    }
-  }
-  return $check
-}
-
-#
-# @proj-bin-define binName ?defName?
-#
-# Uses [proj-find-executable-path $binName] to (verbosely) search for
-# a binary, sets a define (see below) to the result, and returns the
-# result (an empty string if not found).
-#
-# The define'd name is: If $defName is not empty, it is used as-is. If
-# $defName is empty then "BIN_X" is used, where X is the upper-case
-# form of $binName with any '-' characters replaced with '_'.
-#
-proc proj-bin-define {binName {defName {}}} {
-  set check [proj-find-executable-path -v $binName]
-  if {"" eq $defName} {
-    set defName "BIN_[string toupper [string map {- _} $binName]]"
-  }
-  define $defName $check
-  return $check
-}
-
-#
-# @proj-first-bin-of bin...
-#
-# Looks for the first binary found of the names passed to this
-# function.  If a match is found, the full path to that binary is
-# returned, else "" is returned.
-#
-# Despite using cc-path-progs to do the search, this function clears
-# any define'd name that function stores for the result (because the
-# caller has no sensible way of knowing which [define] name it has
-# unless they pass only a single argument).
-#
-proc proj-first-bin-of {args} {
-  set rc ""
-  foreach b $args {
-    set u [string toupper $b]
-    # Note that cc-path-progs defines $u to "false" if it finds no
-    # match.
-    if {[cc-path-progs $b]} {
-      set rc [get-define $u]
-    }
-    undefine $u
-    if {"" ne $rc} break
-  }
-  return $rc
-}
-
-#
-# @proj-opt-was-provided key
-#
-# Returns 1 if the user specifically provided the given configure flag
-# or if it was specifically set using proj-opt-set, else 0. This can
-# be used to distinguish between options which have a default value
-# and those which were explicitly provided by the user, even if the
-# latter is done in a way which uses the default value.
-#
-# For example, with a configure flag defined like:
-#
-#   { foo-bar:=baz => {its help text} }
-#
-# This function will, when passed foo-bar, return 1 only if the user
-# passes --foo-bar to configure, even if that invocation would resolve
-# to the default value of baz. If the user does not explicitly pass in
-# --foo-bar (with or without a value) then this returns 0.
-#
-# Calling [proj-opt-set] is, for purposes of the above, equivalent to
-# explicitly passing in the flag.
-#
-# Note: unlike most functions which deal with configure --flags, this
-# one does not validate that $key refers to a pre-defined flag. i.e.
-# it accepts arbitrary keys, even those not defined via an [options]
-# call. [proj-opt-set] manipulates the internal list of flags, such
-# that new options set via that function will cause this function to
-# return true. (That's an unintended and unavoidable side-effect, not
-# specifically a feature which should be made use of.)
-#
-proc proj-opt-was-provided {key} {
-  dict exists $::autosetup(optset) $key
-}
-
-#
-# @proj-opt-set flag ?val?
-#
-# Force-set autosetup option $flag to $val. The value can be fetched
-# later with [opt-val], [opt-bool], and friends.
-#
-# Returns $val.
-#
-proc proj-opt-set {flag {val 1}} {
-  if {$flag ni $::autosetup(options)} {
-    # We have to add this to autosetup(options) or else future calls
-    # to [opt-bool $flag] will fail validation of $flag.
-    lappend ::autosetup(options) $flag
-  }
-  dict set ::autosetup(optset) $flag $val
-  return $val
-}
-
-#
-# @proj-opt-exists flag
-#
-# Returns 1 if the given flag has been defined as a legal configure
-# option, else returns 0. Options set via proj-opt-set "exist" for
-# this purpose even if they were not defined via autosetup's
-# [options] function.
-#
-proc proj-opt-exists {flag} {
-  expr {$flag in $::autosetup(options)};
-}
-
-#
-# @proj-val-truthy val
-#
-# Returns 1 if $val appears to be a truthy value, else returns
-# 0. Truthy values are any of {1 on true yes enabled}
-#
-proc proj-val-truthy {val} {
-  expr {$val in {1 on true yes enabled}}
-}
-
-#
-# @proj-opt-truthy flag
-#
-# Returns 1 if [opt-val $flag] appears to be a truthy value or
-# [opt-bool $flag] is true. See proj-val-truthy.
-#
-proc proj-opt-truthy {flag} {
-  if {[proj-val-truthy [opt-val $flag]]} { return 1 }
-  set rc 0
-  catch {
-    # opt-bool will throw if $flag is not a known boolean flag
-    set rc [opt-bool $flag]
-  }
-  return $rc
-}
-
-#
-# @proj-if-opt-truthy boolFlag thenScript ?elseScript?
-#
-# If [proj-opt-truthy $flag] is true, eval $then, else eval $else.
-#
-proc proj-if-opt-truthy {boolFlag thenScript {elseScript {}}} {
-  if {[proj-opt-truthy $boolFlag]} {
-    uplevel 1 $thenScript
-  } else {
-    uplevel 1 $elseScript
-  }
-}
-
-#
-# @proj-define-for-opt flag def ?msg? ?iftrue? ?iffalse?
-#
-# If [proj-opt-truthy $flag] then [define $def $iftrue] else [define
-# $def $iffalse]. If $msg is not empty, output [msg-checking $msg] and
-# a [msg-results ...] which corresponds to the result. Returns 1 if
-# the opt-truthy check passes, else 0.
-#
-proc proj-define-for-opt {flag def {msg ""} {iftrue 1} {iffalse 0}} {
-  if {"" ne $msg} {
-    msg-checking "$msg "
-  }
-  set rcMsg ""
-  set rc 0
-  if {[proj-opt-truthy $flag]} {
-    define $def $iftrue
-    set rc 1
-  } else {
-    define $def $iffalse
-  }
-  switch -- [proj-val-truthy [get-define $def]] {
-    0 { set rcMsg no }
-    1 { set rcMsg yes }
-  }
-  if {"" ne $msg} {
-    msg-result $rcMsg
-  }
-  return $rc
-}
-
-#
-# @proj-opt-define-bool ?-v? optName defName ?descr?
-#
-# Checks [proj-opt-truthy $optName] and calls [define $defName X]
-# where X is 0 for false and 1 for true. $descr is an optional
-# [msg-checking] argument which defaults to $defName. Returns X.
-#
-# If args[0] is -v then the boolean semantics are inverted: if
-# the option is set, it gets define'd to 0, else 1. Returns the
-# define'd value.
-#
-proc proj-opt-define-bool {args} {
-  set invert 0
-  if {[lindex $args 0] eq "-v"} {
-    incr invert
-    lassign $args - optName defName descr
-  } else {
-    lassign $args optName defName descr
-  }
-  if {"" eq $descr} {
-    set descr $defName
-  }
-  #puts "optName=$optName defName=$defName descr=$descr"
-  set rc 0
-  msg-checking "[join $descr] ... "
-  set rc [proj-opt-truthy $optName]
-  if {$invert} {
-    set rc [expr {!$rc}]
-  }
-  msg-result [string map {0 no 1 yes} $rc]
-  define $defName $rc
-  return $rc
-}
-
-#
-# @proj-check-module-loader
-#
-# Check for module-loading APIs (libdl/libltdl)...
-#
-# Looks for libltdl or dlopen(), the latter either in -ldl or built in
-# to libc (as it is on some platforms). Returns 1 if found, else
-# 0. Either way, it `define`'s:
-#
-#  - HAVE_LIBLTDL to 1 or 0 if libltdl is found/not found
-#  - HAVE_LIBDL to 1 or 0 if dlopen() is found/not found
-#  - LDFLAGS_MODULE_LOADER one of ("-lltdl", "-ldl", or ""), noting
-#    that -ldl may legally be empty on some platforms even if
-#    HAVE_LIBDL is true (indicating that dlopen() is available without
-#    extra link flags). LDFLAGS_MODULE_LOADER also gets "-rdynamic" appended
-#    to it because otherwise trying to open DLLs will result in undefined
-#    symbol errors.
-#
-# Note that if it finds LIBLTDL it does not look for LIBDL, so will
-# report only that is has LIBLTDL.
-#
-proc proj-check-module-loader {} {
-  msg-checking "Looking for module-loader APIs... "
-  if {99 ne [get-define LDFLAGS_MODULE_LOADER 99]} {
-    if {1 eq [get-define HAVE_LIBLTDL 0]} {
-      msg-result "(cached) libltdl"
-      return 1
-    } elseif {1 eq [get-define HAVE_LIBDL 0]} {
-      msg-result "(cached) libdl"
-      return 1
-    }
-    # else: wha???
-  }
-  set HAVE_LIBLTDL 0
-  set HAVE_LIBDL 0
-  set LDFLAGS_MODULE_LOADER ""
-  set rc 0
-  puts "" ;# cosmetic kludge for cc-check-XXX
-  if {[cc-check-includes ltdl.h] && [cc-check-function-in-lib lt_dlopen ltdl]} {
-    set HAVE_LIBLTDL 1
-    set LDFLAGS_MODULE_LOADER "-lltdl -rdynamic"
-    msg-result " - Got libltdl."
-    set rc 1
-  } elseif {[cc-with {-includes dlfcn.h} {
-    cctest -link 1 -declare "extern char* dlerror(void);" -code "dlerror();"}]} {
-    msg-result " - This system can use dlopen() without -ldl."
-    set HAVE_LIBDL 1
-    set LDFLAGS_MODULE_LOADER ""
-    set rc 1
-  } elseif {[cc-check-includes dlfcn.h]} {
-    set HAVE_LIBDL 1
-    set rc 1
-    if {[cc-check-function-in-lib dlopen dl]} {
-      msg-result " - dlopen() needs libdl."
-      set LDFLAGS_MODULE_LOADER "-ldl -rdynamic"
-    } else {
-      msg-result " - dlopen() not found in libdl. Assuming dlopen() is built-in."
-      set LDFLAGS_MODULE_LOADER "-rdynamic"
-    }
-  }
-  define HAVE_LIBLTDL $HAVE_LIBLTDL
-  define HAVE_LIBDL $HAVE_LIBDL
-  define LDFLAGS_MODULE_LOADER $LDFLAGS_MODULE_LOADER
-  return $rc
-}
-
-#
-# @proj-no-check-module-loader
-#
-# Sets all flags which would be set by proj-check-module-loader to
-# empty/falsy values, as if those checks had failed to find a module
-# loader. Intended to be called in place of that function when
-# a module loader is explicitly not desired.
-#
-proc proj-no-check-module-loader {} {
-  define HAVE_LIBDL 0
-  define HAVE_LIBLTDL 0
-  define LDFLAGS_MODULE_LOADER ""
-}
-
-#
-# @proj-file-content ?-trim? filename
-#
-# Opens the given file, reads all of its content, and returns it.  If
-# the first arg is -trim, the contents of the file named by the second
-# argument are trimmed before returning them.
-#
-proc proj-file-content {args} {
-  set trim 0
-  set fname $args
-  if {"-trim" eq [lindex $args 0]} {
-    set trim 1
-    lassign $args - fname
-  }
-  set fp [open $fname rb]
-  set rc [read $fp]
-  close $fp
-  if {$trim} { return [string trim $rc] }
-  return $rc
-}
-
-#
-# @proj-file-conent filename
-#
-# Returns the contents of the given file as an array of lines, with
-# the EOL stripped from each input line.
-#
-proc proj-file-content-list {fname} {
-  set fp [open $fname rb]
-  set rc {}
-  while { [gets $fp line] >= 0 } {
-    lappend rc $line
-  }
-  close $fp
-  return $rc
-}
-
-#
-# @proj-file-write ?-ro? fname content
-#
-# Works like autosetup's [writefile] but explicitly uses binary mode
-# to avoid EOL translation on Windows. If $fname already exists, it is
-# overwritten, even if it's flagged as read-only.
-#
-proc proj-file-write {args} {
-  if {"-ro" eq [lindex $args 0]} {
-    lassign $args ro fname content
-  } else {
-    set ro ""
-    lassign $args fname content
-  }
-  file delete -force -- $fname; # in case it's read-only
-  set f [open $fname wb]
-  puts -nonewline $f $content
-  close $f
-  if {"" ne $ro} {
-    catch {
-      exec chmod -w $fname
-      #file attributes -w $fname; #jimtcl has no 'attributes'
-    }
-  }
-}
-
-#
-# @proj-check-compile-commands ?-assume-for-clang? ?configFlag?
-#
-# Checks the compiler for compile_commands.json support. If
-# $configFlag is not empty then it is assumed to be the name of an
-# autosetup boolean config which controls whether to run/skip this
-# check.
-#
-# If -assume-for-clang is provided and $configFlag is not empty and CC
-# matches *clang* and no --$configFlag was explicitly provided to the
-# configure script then behave as if --$configFlag had been provided.
-# To disable that assumption, either don't pass -assume-for-clang or
-# pass --$configFlag=0 to the configure script. (The reason for this
-# behavior is that clang supports compile-commands but some other
-# compilers report false positives with these tests.)
-#
-# Returns 1 if supported, else 0, and defines HAVE_COMPILE_COMMANDS to
-# that value. Defines MAKE_COMPILATION_DB to "yes" if supported, "no"
-# if not. The use of MAKE_COMPILATION_DB is deprecated/discouraged:
-# HAVE_COMPILE_COMMANDS is preferred.
-#
-# ACHTUNG: this test has a long history of false positive results
-# because of compilers reacting differently to the -MJ flag.  Because
-# of this, it is recommended that this support be an opt-in feature,
-# rather than an on-by-default default one. That is: in the
-# configure script define the option as
-# {--the-flag-name=0 => {Enable ....}}
-#
-proc proj-check-compile-commands {args} {
-  set i 0
-  set configFlag {}
-  set fAssumeForClang 0
-  set doAssume 0
-  msg-checking "compile_commands.json support... "
-  if {"-assume-for-clang" eq [lindex $args 0]} {
-    lassign $args - configFlag
-    incr fAssumeForClang
-  } elseif {1 == [llength $args]} {
-    lassign $args configFlag
-  } else {
-    proj-error "Invalid arguments"
-  }
-  if {1 == $fAssumeForClang && "" ne $configFlag} {
-    if {[string match *clang* [get-define CC]]
-        && ![proj-opt-was-provided $configFlag]
-        && ![proj-opt-truthy $configFlag]} {
-      proj-indented-notice [subst -nocommands -nobackslashes {
-        CC appears to be clang, so assuming that --$configFlag is likely
-        to work. To disable this assumption use --$configFlag=0.}]
-      incr doAssume
-    }
-  }
-  if {!$doAssume && "" ne $configFlag && ![proj-opt-truthy $configFlag]} {
-    msg-result "check disabled. Use --${configFlag} to enable it."
-    define HAVE_COMPILE_COMMANDS 0
-    define MAKE_COMPILATION_DB no
-    return 0
-  } else {
-    if {[cctest -lang c -cflags {/dev/null -MJ} -source {}]} {
-      # This test reportedly incorrectly succeeds on one of
-      # Martin G.'s older systems. drh also reports a false
-      # positive on an unspecified older Mac system.
-      msg-result "compiler supports -MJ. Assuming it's useful for compile_commands.json"
-      define MAKE_COMPILATION_DB yes; # deprecated
-      define HAVE_COMPILE_COMMANDS 1
-      return 1
-    } else {
-      msg-result "compiler does not support compile_commands.json"
-      define MAKE_COMPILATION_DB no
-      define HAVE_COMPILE_COMMANDS 0
-      return 0
-    }
-  }
-}
-
-#
-# @proj-touch filename
-#
-# Runs the 'touch' external command on one or more files, ignoring any
-# errors.
-#
-proc proj-touch {filename} {
-  catch { exec touch {*}$filename }
-}
-
-#
-# @proj-make-from-dot-in ?-touch? infile ?outfile?
-#
-# Uses [make-template] to create makefile(-like) file(s) $outfile from
-# $infile but explicitly makes the output read-only, to avoid
-# inadvertent editing (who, me?).
-#
-# If $outfile is empty then:
-#
-# - If $infile is a 2-element list, it is assumed to be an in/out pair,
-#   and $outfile is set from the 2nd entry in that list. Else...
-#
-# - $outfile is set to $infile stripped of its extension.
-#
-# If the first argument is -touch then the generated file is touched
-# to update its timestamp. This can be used as a workaround for
-# cases where (A) autosetup does not update the file because it was
-# not really modified and (B) the file *really* needs to be updated to
-# please the build process.
-#
-# Failures when running chmod or touch are silently ignored.
-#
-proc proj-make-from-dot-in {args} {
-  set fIn ""
-  set fOut ""
-  set touch 0
-  if {[lindex $args 0] eq "-touch"} {
-    set touch 1
-    lassign $args - fIn fOut
-  } else {
-    lassign $args fIn fOut
-  }
-  if {"" eq $fOut} {
-    if {[llength $fIn]>1} {
-      lassign $fIn fIn fOut
-    } else {
-      set fOut [file rootname $fIn]
-    }
-  }
-  #puts "filenames=$filename"
-  if {[file exists $fOut]} {
-    catch { exec chmod u+w $fOut }
-  }
-  #puts "making template: $fIn ==> $fOut"
-  #define-push {top_srcdir} {
-    #puts "--- $fIn $fOut top_srcdir=[get-define top_srcdir]"
-    make-template $fIn $fOut
-    #puts "--- $fIn $fOut top_srcdir=[get-define top_srcdir]"
-    # make-template modifies top_srcdir
-  #}
-  if {$touch} {
-    proj-touch $fOut
-  }
-  catch {
-    exec chmod -w $fOut
-    #file attributes -w $f; #jimtcl has no 'attributes'
-  }
-}
-
-#
-# @proj-check-profile-flag ?flagname?
-#
-# Checks for the boolean configure option named by $flagname. If set,
-# it checks if $CC seems to refer to gcc. If it does (or appears to)
-# then it defines CC_PROFILE_FLAG to "-pg" and returns 1, else it
-# defines CC_PROFILE_FLAG to "" and returns 0.
-#
-# Note that the resulting flag must be added to both CFLAGS and
-# LDFLAGS in order for binaries to be able to generate "gmon.out".  In
-# order to avoid potential problems with escaping, space-containing
-# tokens, and interfering with autosetup's use of these vars, this
-# routine does not directly modify CFLAGS or LDFLAGS.
-#
-proc proj-check-profile-flag {{flagname profile}} {
-  #puts "flagname=$flagname ?[proj-opt-truthy $flagname]?"
-  if {[proj-opt-truthy $flagname]} {
-    set CC [get-define CC]
-    regsub {.*ccache *} $CC "" CC
-    # ^^^ if CC="ccache gcc" then [exec] treats "ccache gcc" as a
-    # single binary name and fails. So strip any leading ccache part
-    # for this purpose.
-    if { ![catch { exec $CC --version } msg]} {
-      if {[string first gcc $CC] != -1} {
-        define CC_PROFILE_FLAG "-pg"
-        return 1
-      }
-    }
-  }
-  define CC_PROFILE_FLAG ""
-  return 0
-}
-
-#
-# @proj-looks-like-windows ?key?
-#
-# Returns 1 if this appears to be a Windows environment (MinGw,
-# Cygwin, MSys), else returns 0. The optional argument is the name of
-# an autosetup define which contains platform name info, defaulting to
-# "host" (meaning, somewhat counterintuitively, the target system, not
-# the current host). The other legal value is "build" (the build
-# machine, i.e. the local host). If $key == "build" then some
-# additional checks may be performed which are not applicable when
-# $key == "host".
-#
-proc proj-looks-like-windows {{key host}} {
-  global autosetup
-  switch -glob -- [get-define $key] {
-    *-*-ming* - *-*-cygwin - *-*-msys - *windows* {
-      return 1
-    }
-  }
-  if {$key eq "build"} {
-    # These apply only to the local OS, not a cross-compilation target,
-    # as the above check potentially can.
-    if {$::autosetup(iswin)} { return 1 }
-    if {[find-an-executable cygpath] ne "" || $::tcl_platform(os) eq "Windows NT"} {
-      return 1
-    }
-  }
-  return 0
-}
-
-#
-# @proj-looks-like-mac ?key?
-#
-# Looks at either the 'host' (==compilation target platform) or
-# 'build' (==the being-built-on platform) define value and returns if
-# if that value seems to indicate that it represents a Mac platform,
-# else returns 0.
-#
-proc proj-looks-like-mac {{key host}} {
-  switch -glob -- [get-define $key] {
-    *-*-darwin* {
-      # https://sqlite.org/forum/forumpost/7b218c3c9f207646
-      # There's at least one Linux out there which matches *apple*.
-      return 1
-    }
-    default {
-      return 0
-    }
-  }
-}
-
-#
-# @proj-exe-extension
-#
-# Checks autosetup's "host" and "build" defines to see if the build
-# host and target are Windows-esque (Cygwin, MinGW, MSys). If the
-# build environment is then BUILD_EXEEXT is [define]'d to ".exe", else
-# "". If the target, a.k.a. "host", is then TARGET_EXEEXT is
-# [define]'d to ".exe", else "".
-#
-proc proj-exe-extension {} {
-  set rH ""
-  set rB ""
-  if {[proj-looks-like-windows host]} {
-    set rH ".exe"
-  }
-  if {[proj-looks-like-windows build]} {
-    set rB ".exe"
-  }
-  define BUILD_EXEEXT $rB
-  define TARGET_EXEEXT $rH
-}
-
-#
-# @proj-dll-extension
-#
-# Works like proj-exe-extension except that it defines BUILD_DLLEXT
-# and TARGET_DLLEXT to one of (.so, ,dll, .dylib).
-#
-# Trivia: for .dylib files, the linker needs the -dynamiclib flag
-# instead of -shared.
-#
-proc proj-dll-extension {} {
-  set inner {{key} {
-    if {[proj-looks-like-mac $key]} {
-      return ".dylib"
-    }
-    if {[proj-looks-like-windows $key]} {
-      return ".dll"
-    }
-    return ".so"
-  }}
-  define BUILD_DLLEXT [apply $inner build]
-  define TARGET_DLLEXT [apply $inner host]
-}
-
-#
-# @proj-lib-extension
-#
-# Static-library counterpart of proj-dll-extension. Defines
-# BUILD_LIBEXT and TARGET_LIBEXT to the conventional static library
-# extension for the being-built-on resp. the target platform.
-#
-proc proj-lib-extension {} {
-  set inner {{key} {
-    switch -glob -- [get-define $key] {
-      *-*-ming* - *-*-cygwin - *-*-msys {
-        return ".a"
-        # ^^^ this was ".lib" until 2025-02-07. See
-        # https://sqlite.org/forum/forumpost/02db2d4240
-      }
-      default {
-        return ".a"
-      }
-    }
-  }}
-  define BUILD_LIBEXT [apply $inner build]
-  define TARGET_LIBEXT [apply $inner host]
-}
-
-#
-# @proj-file-extensions
-#
-# Calls all of the proj-*-extension functions.
-#
-proc proj-file-extensions {} {
-  proj-exe-extension
-  proj-dll-extension
-  proj-lib-extension
-}
-
-#
-# @proj-affirm-files-exist ?-v? filename...
-#
-# Expects a list of file names. If any one of them does not exist in
-# the filesystem, it fails fatally with an informative message.
-# Returns the last file name it checks. If the first argument is -v
-# then it emits msg-checking/msg-result messages for each file.
-#
-proc proj-affirm-files-exist {args} {
-  set rc ""
-  set verbose 0
-  if {[lindex $args 0] eq "-v"} {
-    set verbose 1
-    set args [lrange $args 1 end]
-  }
-  foreach f $args {
-    if {$verbose} { msg-checking "Looking for $f ... " }
-    if {![file exists $f]} {
-      user-error "not found: $f"
-    }
-    if {$verbose} { msg-result "" }
-    set rc $f
-  }
-  return rc
-}
-
-#
-# @proj-check-emsdk
-#
-# Emscripten is used for doing in-tree builds of web-based WASM stuff,
-# as opposed to WASI-based WASM or WASM binaries we import from other
-# places. This is only set up for Unix-style OSes and is untested
-# anywhere but Linux. Requires that the --with-emsdk flag be
-# registered with autosetup.
-#
-# It looks for the SDK in the location specified by --with-emsdk.
-# Values of "" or "auto" mean to check for the environment var EMSDK
-# (which gets set by the emsdk_env.sh script from the SDK) or that
-# same var passed to configure.
-#
-# If the given directory is found, it expects to find emsdk_env.sh in
-# that directory, as well as the emcc compiler somewhere under there.
-#
-# If the --with-emsdk[=DIR] flag is explicitly provided and the SDK is
-# not found then a fatal error is generated, otherwise failure to find
-# the SDK is not fatal.
-#
-# Defines the following:
-#
-# - HAVE_EMSDK = 0 or 1 (this function's return value)
-# - EMSDK_HOME = "" or top dir of the emsdk
-# - EMSDK_ENV_SH = "" or $EMSDK_HOME/emsdk_env.sh
-# - BIN_EMCC = "" or $EMSDK_HOME/upstream/emscripten/emcc
-#
-# Returns 1 if EMSDK_ENV_SH is found, else 0.  If EMSDK_HOME is not empty
-# but BIN_EMCC is then emcc was not found in the EMSDK_HOME, in which
-# case we have to rely on the fact that sourcing $EMSDK_ENV_SH from a
-# shell will add emcc to the $PATH.
-#
-proc proj-check-emsdk {} {
-  set emsdkHome [opt-val with-emsdk]
-  define EMSDK_HOME ""
-  define EMSDK_ENV_SH ""
-  define BIN_EMCC ""
-  set hadValue [llength $emsdkHome]
-  msg-checking "Emscripten SDK? "
-  if {$emsdkHome in {"" "auto"}} {
-    # Check the environment. $EMSDK gets set by sourcing emsdk_env.sh.
-    set emsdkHome [get-env EMSDK ""]
-  }
-  set rc 0
-  if {$emsdkHome ne ""} {
-    define EMSDK_HOME $emsdkHome
-    set emsdkEnv "$emsdkHome/emsdk_env.sh"
-    if {[file exists $emsdkEnv]} {
-      msg-result "$emsdkHome"
-      define EMSDK_ENV_SH $emsdkEnv
-      set rc 1
-      set emcc "$emsdkHome/upstream/emscripten/emcc"
-      if {[file exists $emcc]} {
-        define BIN_EMCC $emcc
-      }
-    } else {
-      msg-result "emsdk_env.sh not found in $emsdkHome"
-    }
-  } else {
-    msg-result "not found"
-  }
-  if {$hadValue && 0 == $rc} {
-    # Fail if it was explicitly requested but not found
-    proj-fatal "Cannot find the Emscripten SDK"
-  }
-  define HAVE_EMSDK $rc
-  return $rc
-}
-
-#
-# @proj-cc-check-Wl-flag ?flag ?args??
-#
-# Checks whether the given linker flag (and optional arguments) can be
-# passed from the compiler to the linker using one of these formats:
-#
-# - -Wl,flag[,arg1[,...argN]]
-# - -Wl,flag -Wl,arg1 ...-Wl,argN
-#
-# If so, that flag string is returned, else an empty string is
-# returned.
-#
-proc proj-cc-check-Wl-flag {args} {
-  cc-with {-link 1} {
-    # Try -Wl,flag,...args
-    set fli "-Wl"
-    foreach f $args { append fli ",$f" }
-    if {[cc-check-flags $fli]} {
-      return $fli
-    }
-    # Try -Wl,flag -Wl,arg1 ...-Wl,argN
-    set fli ""
-    foreach f $args { append fli "-Wl,$f " }
-    if {[cc-check-flags $fli]} {
-      return [string trim $fli]
-    }
-    return ""
-  }
-}
-
-#
-# @proj-check-rpath
-#
-# Tries various approaches to handling the -rpath link-time
-# flag. Defines LDFLAGS_RPATH to that/those flag(s) or an empty
-# string. Returns 1 if it finds an option, else 0.
-#
-# By default, the rpath is set to $prefix/lib. However, if either of
-# --exec-prefix=... or --libdir=...  are explicitly passed to
-# configure then [get-define libdir] is used (noting that it derives
-# from exec-prefix by default).
-#
-proc proj-check-rpath {} {
-  if {[proj-opt-was-provided libdir]
-      || [proj-opt-was-provided exec-prefix]} {
-    set lp "[get-define libdir]"
-  } else {
-    set lp "[get-define prefix]/lib"
-  }
-  # If we _don't_ use cc-with {} here (to avoid updating the global
-  # CFLAGS or LIBS or whatever it is that cc-check-flags updates) then
-  # downstream tests may fail because the resulting rpath gets
-  # implicitly injected into them.
-  cc-with {-link 1} {
-    if {[cc-check-flags "-rpath $lp"]} {
-      define LDFLAGS_RPATH "-rpath $lp"
-    } else {
-      set wl [proj-cc-check-Wl-flag -rpath $lp]
-      if {"" eq $wl} {
-        set wl [proj-cc-check-Wl-flag -R$lp]
-      }
-      if {"" eq $wl} {
-        # HP-UX: https://sqlite.org/forum/forumpost/d80ecdaddd
-        set wl [proj-cc-check-Wl-flag +b $lp]
-      }
-      define LDFLAGS_RPATH $wl
-    }
-  }
-  expr {"" ne [get-define LDFLAGS_RPATH]}
-}
-
-#
-# @proj-check-soname ?libname?
-#
-# Checks whether CC supports the -Wl,-soname,lib... flag. If so, it
-# returns 1 and defines LDFLAGS_SONAME_PREFIX to the flag's prefix, to
-# which the client would need to append "libwhatever.N".  If not, it
-# returns 0 and defines LDFLAGS_SONAME_PREFIX to an empty string.
-#
-# The libname argument is only for purposes of running the flag
-# compatibility test, and is not included in the resulting
-# LDFLAGS_SONAME_PREFIX. It is provided so that clients may
-# potentially avoid some end-user confusion by using their own lib's
-# name here (which shows up in the "checking..." output).
-#
-proc proj-check-soname {{libname "libfoo.so.0"}} {
-  cc-with {-link 1} {
-    if {[cc-check-flags "-Wl,-soname,${libname}"]} {
-      define LDFLAGS_SONAME_PREFIX "-Wl,-soname,"
-      return 1
-    } elseif {[cc-check-flags "-Wl,+h,${libname}"]} {
-      # HP-UX: https://sqlite.org/forum/forumpost/d80ecdaddd
-      define LDFLAGS_SONAME_PREFIX "-Wl,+h,"
-      return 1
-    } else {
-      define LDFLAGS_SONAME_PREFIX ""
-      return 0
-    }
-  }
-}
-
-#
-# @proj-check-fsanitize ?list-of-opts?
-#
-# Checks whether CC supports -fsanitize=X, where X is each entry of
-# the given list of flags. If any of those flags are supported, it
-# returns the string "-fsanitize=X..." where X... is a comma-separated
-# list of all flags from the original set which are supported. If none
-# of the given options are supported then it returns an empty string.
-#
-# Example:
-#
-#  set f [proj-check-fsanitize {address bounds-check just-testing}]
-#
-# Will, on many systems, resolve to "-fsanitize=address,bounds-check",
-# but may also resolve to "-fsanitize=address".
-#
-proc proj-check-fsanitize {{opts {address bounds-strict}}} {
-  set sup {}
-  foreach opt $opts {
-    # -nooutput is used because -fsanitize=hwaddress will otherwise
-    # pass this test on x86_64, but then warn at build time that
-    # "hwaddress is not supported for this target".
-    cc-with {-nooutput 1} {
-      if {[cc-check-flags "-fsanitize=$opt"]} {
-        lappend sup $opt
-      }
-    }
-  }
-  if {[llength $sup] > 0} {
-    return "-fsanitize=[join $sup ,]"
-  }
-  return ""
-}
-
-#
-# Internal helper for proj-dump-defs-json. Expects to be passed a
-# [define] name and the variadic $args which are passed to
-# proj-dump-defs-json. If it finds a pattern match for the given
-# $name in the various $args, it returns the type flag for that $name,
-# e.g. "-str" or "-bare", else returns an empty string.
-#
-proc proj-defs-type_ {name spec} {
-  foreach {type patterns} $spec {
-    foreach pattern $patterns {
-      if {[string match $pattern $name]} {
-        return $type
-      }
-    }
-  }
-  return ""
-}
-
-#
-# Internal helper for proj-defs-format_: returns a JSON-ish quoted
-# form of the given string-type values. It only performs the most
-# basic of escaping. The input must not contain any control
-# characters.
-#
-proc proj-quote-str_ {value} {
-  return \"[string map [list \\ \\\\ \" \\\"] $value]\"
-}
-
-#
-# An internal impl detail of proj-dump-defs-json. Requires a data
-# type specifier, as used by make-config-header, and a value. Returns
-# the formatted value or the value $::proj__Config(defs-skip) if the caller
-# should skip emitting that value.
-#
-set ::proj__Config(defs-skip) "-proj-defs-format_ sentinel"
-proc proj-defs-format_ {type value} {
-  switch -exact -- $type {
-    -bare {
-      # Just output the value unchanged
-    }
-    -none {
-      set value $::proj__Config(defs-skip)
-    }
-    -str {
-      set value [proj-quote-str_ $value]
-    }
-    -auto {
-      # Automatically determine the type
-      if {![string is integer -strict $value]} {
-        set value [proj-quote-str_ $value]
-      }
-    }
-    -array {
-      set ar {}
-      foreach v $value {
-        set v [proj-defs-format_ -auto $v]
-        if {$::proj__Config(defs-skip) ne $v} {
-          lappend ar $v
-        }
-      }
-      set value "\[ [join $ar {, }] \]"
-    }
-    "" {
-      set value $::proj__Config(defs-skip)
-    }
-    default {
-      proj-fatal "Unknown type in proj-dump-defs-json: $type"
-    }
-  }
-  return $value
-}
-
-#
-# @proj-dump-defs-json outfile ...flags
-#
-# This function works almost identically to autosetup's
-# make-config-header but emits its output in JSON form. It is not a
-# fully-functional JSON emitter, and will emit broken JSON for
-# complicated outputs, but should be sufficient for purposes of
-# emitting most configure vars (numbers and simple strings).
-#
-# In addition to the formatting flags supported by make-config-header,
-# it also supports:
-#
-#  -array {patterns...}
-#
-# Any defines matching the given patterns will be treated as a list of
-# values, each of which will be formatted as if it were in an -auto {...}
-# set, and the define will be emitted to JSON in the form:
-#
-#  "ITS_NAME": [ "value1", ...valueN ]
-#
-# Achtung: if a given -array pattern contains values which themselves
-# contains spaces...
-#
-#   define-append foo {"-DFOO=bar baz" -DBAR="baz barre"}
-#
-# will lead to:
-#
-#  ["-DFOO=bar baz", "-DBAR=\"baz", "barre\""]
-#
-# Neither is especially satisfactory (and the second is useless), and
-# handling of such values is subject to change if any such values ever
-# _really_ need to be processed by our source trees.
-#
-proc proj-dump-defs-json {file args} {
-  file mkdir [file dirname $file]
-  set lines {}
-  lappend args -bare {SIZEOF_* HAVE_DECL_*} -auto HAVE_*
-  foreach n [lsort [dict keys [all-defines]]] {
-    set type [proj-defs-type_ $n $args]
-    set value [proj-defs-format_ $type [get-define $n]]
-    if {$::proj__Config(defs-skip) ne $value} {
-      lappend lines "\"$n\": ${value}"
-    }
-  }
-  set buf {}
-  lappend buf [join $lines ",\n"]
-  write-if-changed $file $buf {
-    msg-result "Created $file"
-  }
-}
-
-#
-# @proj-xfer-option-aliases map
-#
-# Expects a list of pairs of configure flags which have been
-# registered with autosetup, in this form:
-#
-#  { alias1 => canonical1
-#    aliasN => canonicalN ... }
-#
-# The names must not have their leading -- part and must be in the
-# form which autosetup will expect for passing to [opt-val NAME] and
-# friends.
-#
-# Comment lines are permitted in the input.
-#
-# For each pair of ALIAS and CANONICAL, if --ALIAS is provided but
-# --CANONICAL is not, the value of the former is copied to the
-# latter. If --ALIAS is not provided, this is a no-op. If both have
-# explicitly been provided a fatal usage error is triggered.
-#
-# Motivation: autosetup enables "hidden aliases" in [options] lists,
-# and elides the aliases from --help output but does no further
-# handling of them. For example, when --alias is a hidden alias of
-# --canonical and a user passes --alias=X, [opt-val canonical] returns
-# no value. i.e. the script must check both [opt-val alias] and
-# [opt-val canonical].  The intent here is that this function be
-# passed such mappings immediately after [options] is called, to carry
-# over any values from hidden aliases into their canonical names, such
-# that [opt-value canonical] will return X if --alias=X is passed to
-# configure.
-#
-# That said: autosetup's [opt-str] does support alias forms, but it
-# requires that the caller know all possible aliases. It's simpler, in
-# terms of options handling, if there's only a single canonical name
-# which each down-stream call of [opt-...] has to know.
-#
-proc proj-xfer-options-aliases {mapping} {
-  foreach {hidden - canonical} [proj-strip-hash-comments $mapping] {
-    if {[proj-opt-was-provided $hidden]} {
-      if {[proj-opt-was-provided $canonical]} {
-        proj-fatal "both --$canonical and its alias --$hidden were used. Use only one or the other."
-      } else {
-        proj-opt-set $canonical [opt-val $hidden]
-      }
-    }
-  }
-}
-
-#
-# Arguable/debatable...
-#
-# When _not_ cross-compiling and CC_FOR_BUILD is _not_ explicitly
-# specified, force CC_FOR_BUILD to be the same as CC, so that:
-#
-# ./configure CC=clang
-#
-# will use CC_FOR_BUILD=clang, instead of cc, for building in-tree
-# tools. This is based off of an email discussion and is thought to
-# be likely to cause less confusion than seeing 'cc' invocations
-# when when the user passes CC=clang.
-#
-# Sidebar: if we do this before the cc package is installed, it gets
-# reverted by that package. Ergo, the cc package init will tell the
-# user "Build C compiler...cc" shortly before we tell them otherwise.
-#
-proc proj-redefine-cc-for-build {} {
-  if {![proj-is-cross-compiling]
-      && [get-define CC] ne [get-define CC_FOR_BUILD]
-      && "nope" eq [get-env CC_FOR_BUILD "nope"]} {
-    user-notice "Re-defining CC_FOR_BUILD to CC=[get-define CC]. To avoid this, explicitly pass CC_FOR_BUILD=..."
-    define CC_FOR_BUILD [get-define CC]
-  }
-}
-
-#
-# @proj-which-linenoise headerFile
-#
-# Attempts to determine whether the given linenoise header file is of
-# the "antirez" or "msteveb" flavor. It returns 2 for msteveb, else 1
-# (it does not validate that the header otherwise contains the
-# linenoise API).
-#
-proc proj-which-linenoise {dotH} {
-  set srcHeader [proj-file-content $dotH]
-  if {[string match *userdata* $srcHeader]} {
-    return 2
-  } else {
-    return 1
-  }
-}
-
-#
-# @proj-remap-autoconf-dir-vars
-#
-# "Re-map" the autoconf-conventional --XYZdir flags into something
-# which is more easily overridable from a make invocation.
-#
-# Based off of notes in <https://sqlite.org/forum/forumpost/00d12a41f7>.
-#
-# Consider:
-#
-# $ ./configure --prefix=/foo
-# $ make install prefix=/blah
-#
-# In that make invocation, $(libdir) would, at make-time, normally be
-# hard-coded to /foo/lib, rather than /blah/lib. That happens because
-# autosetup exports conventional $prefix-based values for the numerous
-# autoconfig-compatible XYZdir vars at configure-time.  What we would
-# normally want, however, is that --libdir derives from the make-time
-# $(prefix).  The distinction between configure-time and make-time is
-# the significant factor there.
-#
-# This function attempts to reconcile those vars in such a way that
-# they will derive, at make-time, from $(prefix) in a conventional
-# manner unless they are explicitly overridden at configure-time, in
-# which case those overrides takes precedence.
-#
-# Each autoconf-relvant --XYZ flag which is explicitly passed to
-# configure is exported as-is, as are those which default to some
-# top-level system directory, e.g. /etc or /var.  All which derive
-# from either $prefix or $exec_prefix are exported in the form of a
-# Makefile var reference, e.g.  libdir=${exec_prefix}/lib. Ergo, if
-# --exec-prefix=FOO is passed to configure, libdir will still derive,
-# at make-time, from whatever exec_prefix is passed to make, and will
-# use FOO if exec_prefix is not overridden at make-time.  Without this
-# post-processing, libdir would be cemented in as FOO/lib at
-# configure-time, so could be tedious to override properly via a make
-# invocation.
-#
-proc proj-remap-autoconf-dir-vars {} {
-  set prefix [get-define prefix]
-  set exec_prefix [get-define exec_prefix $prefix]
-  # The following var derefs must be formulated such that they are
-  # legal for use in (A) makefiles, (B) pkgconfig files, and (C) TCL's
-  # [subst] command.  i.e. they must use the form ${X}.
-  foreach {flag makeVar makeDeref} {
-    exec-prefix     exec_prefix    ${prefix}
-    datadir         datadir        ${prefix}/share
-    mandir          mandir         ${datadir}/man
-    includedir      includedir     ${prefix}/include
-    bindir          bindir         ${exec_prefix}/bin
-    libdir          libdir         ${exec_prefix}/lib
-    sbindir         sbindir        ${exec_prefix}/sbin
-    sysconfdir      sysconfdir     /etc
-    sharedstatedir  sharedstatedir ${prefix}/com
-    localstatedir   localstatedir  /var
-    runstatedir     runstatedir    /run
-    infodir         infodir        ${datadir}/info
-    libexecdir      libexecdir     ${exec_prefix}/libexec
-  } {
-    if {[proj-opt-was-provided $flag]} {
-      define $makeVar [join [opt-val $flag]]
-    } else {
-      define $makeVar [join $makeDeref]
-    }
-    # Maintenance reminder: the [join] call is to avoid {braces}
-    # around the output when someone passes in,
-    # e.g. --libdir=\${prefix}/foo/bar. Debian's SQLite package build
-    # script does that.
-  }
-}
-
-#
-# @proj-env-file flag ?default?
-#
-# If a file named .env-$flag exists, this function returns a
-# trimmed copy of its contents, else it returns $dflt. The intended
-# usage is that things like developer-specific CFLAGS preferences can
-# be stored in .env-CFLAGS.
-#
-proc proj-env-file {flag {dflt ""}} {
-  set fn ".env-${flag}"
-  if {[file readable $fn]} {
-    return [proj-file-content -trim $fn]
-  }
-  return $dflt
-}
-
-#
-# @proj-get-env var ?default?
-#
-# Extracts the value of "environment" variable $var from the first of
-# the following places where it's defined:
-#
-# - Passed to configure as $var=...
-# - Exists as an environment variable
-# - A file named .env-$var (see [proj-env-file])
-#
-# If none of those are set, $dflt is returned.
-#
-proc proj-get-env {var {dflt ""}} {
-  get-env $var [proj-env-file $var $dflt]
-}
-
-#
-# @proj-scope ?lvl?
-#
-# Returns the name of the _calling_ proc from ($lvl + 1) levels up the
-# call stack (where the caller's level will be 1 up from _this_
-# call). If $lvl would resolve to global scope "global scope" is
-# returned and if it would be negative then a string indicating such
-# is returned (as opposed to throwing an error).
-#
-proc proj-scope {{lvl 0}} {
-  #uplevel [expr {$lvl + 1}] {lindex [info level 0] 0}
-  set ilvl [info level]
-  set offset [expr {$ilvl  - $lvl - 1}]
-  if { $offset < 0} {
-    return "invalid scope ($offset)"
-  } elseif { $offset == 0} {
-    return "global scope"
-  } else {
-    return [lindex [info level $offset] 0]
-  }
-}
-
-#
-# Deprecated name of [proj-scope].
-#
-proc proj-current-scope {{lvl 0}} {
-  puts stderr \
-    "Deprecated proj-current-scope called from [proj-scope 1]. Use proj-scope instead."
-  proj-scope [incr lvl]
-}
-
-#
-# Converts parts of tclConfig.sh to autosetup [define]s.
-#
-# Expects to be passed the name of a value tclConfig.sh or an empty
-# string.  It converts certain parts of that file's contents to
-# [define]s (see the code for the whole list). If $tclConfigSh is an
-# empty string then it [define]s the various vars as empty strings.
-#
-proc proj-tclConfig-sh-to-autosetup {tclConfigSh} {
-  set shBody {}
-  set tclVars {
-    TCL_INCLUDE_SPEC
-    TCL_LIBS
-    TCL_LIB_SPEC
-    TCL_STUB_LIB_SPEC
-    TCL_EXEC_PREFIX
-    TCL_PREFIX
-    TCL_VERSION
-    TCL_MAJOR_VERSION
-    TCL_MINOR_VERSION
-    TCL_PACKAGE_PATH
-    TCL_PATCH_LEVEL
-    TCL_SHLIB_SUFFIX
-  }
-  # Build a small shell script which proxies the $tclVars from
-  # $tclConfigSh into autosetup code...
-  lappend shBody "if test x = \"x${tclConfigSh}\"; then"
-  foreach v $tclVars {
-    lappend shBody "$v= ;"
-  }
-  lappend shBody "else . \"${tclConfigSh}\"; fi"
-  foreach v $tclVars {
-    lappend shBody "echo define $v {\$$v} ;"
-  }
-  lappend shBody "exit"
-  set shBody [join $shBody "\n"]
-  #puts "shBody=$shBody\n"; exit
-  eval [exec echo $shBody | sh]
-}
-
-#
-# @proj-tweak-default-env-dirs
-#
-# This function is not useful before [use system] is called to set up
-# --prefix and friends. It should be called as soon after [use system]
-# as feasible.
-#
-# For certain target environments, if --prefix is _not_ passed in by
-# the user, set the prefix to an environment-specific default. For
-# such environments its does [define prefix ...]  and [proj-opt-set
-# prefix ...], but it does not process vars derived from the prefix,
-# e.g. exec-prefix. To do so it is generally necessary to also call
-# proj-remap-autoconf-dir-vars late in the config process (immediately
-# before ".in" files are filtered).
-#
-# Similar modifications may be made for --mandir.
-#
-# Returns >0 if it modifies the environment, else 0.
-#
-proc proj-tweak-default-env-dirs {} {
-  set rc 0
-  switch -glob -- [get-define host] {
-    *-haiku {
-      if {![proj-opt-was-provided prefix]} {
-        set hdir /boot/home/config/non-packaged
-        proj-opt-set prefix $hdir
-        define prefix $hdir
-        incr rc
-      }
-      if {![proj-opt-was-provided mandir]} {
-        set hdir /boot/system/documentation/man
-        proj-opt-set mandir $hdir
-        define mandir $hdir
-        incr rc
-      }
-    }
-  }
-  return $rc
-}
-
-#
-# @proj-dot-ins-append file ?fileOut ?postProcessScript??
-#
-# Queues up an autosetup [make-template]-style file to be processed
-# at a later time using [proj-dot-ins-process].
-#
-# $file is the input file. If $fileOut is empty then this function
-# derives $fileOut from $file, stripping both its directory and
-# extension parts. i.e. it defaults to writing the output to the
-# current directory (typically $::autosetup(builddir)).
-#
-# If $postProcessScript is not empty then, during
-# [proj-dot-ins-process], it will be eval'd immediately after
-# processing the file. In the context of that script, the vars
-# $dotInsIn and $dotInsOut will be set to the input and output file
-# names.  This can be used, for example, to make the output file
-# executable or perform validation on its contents:
-#
-##  proj-dot-ins-append my.sh.in my.sh {
-##    catch {exec chmod u+x $dotInsOut}
-##  }
-#
-# See [proj-dot-ins-process], [proj-dot-ins-list]
-#
-proc proj-dot-ins-append {fileIn args} {
-  set srcdir $::autosetup(srcdir)
-  switch -exact -- [llength $args] {
-    0 {
-      lappend fileIn [file rootname [file tail $fileIn]] ""
-    }
-    1 {
-      lappend fileIn [join $args] ""
-    }
-    2 {
-      lappend fileIn {*}$args
-    }
-    default {
-      proj-fatal "Too many arguments: $fileIn $args"
-    }
-  }
-  #puts "******* [proj-scope]: adding [llength $fileIn]-length item: $fileIn"
-  lappend ::proj__Config(dot-in-files) $fileIn
-}
-
-#
-# @proj-dot-ins-list
-#
-# Returns the current list of [proj-dot-ins-append]'d files, noting
-# that each entry is a 3-element list of (inputFileName,
-# outputFileName, postProcessScript).
-#
-proc proj-dot-ins-list {} {
-  return $::proj__Config(dot-in-files)
-}
-
-#
-# @proj-dot-ins-process ?-touch? ?-validate? ?-clear?
-#
-# Each file which has previously been passed to [proj-dot-ins-append]
-# is processed, with its passing its in-file out-file names to
-# [proj-make-from-dot-in].
-#
-# The intent is that a project accumulate any number of files to
-# filter and delay their actual filtering until the last stage of the
-# configure script, calling this function at that time.
-#
-# Optional flags:
-#
-# -touch: gets passed on to [proj-make-from-dot-in]
-#
-# -validate: after processing each file, before running the file's
-#  associated script, if any, it runs the file through
-#  proj-validate-no-unresolved-ats, erroring out if that does.
-#
-# -clear: after processing, empty the dot-ins list. This effectively
-#  makes proj-dot-ins-append available for re-use.
-#
-proc proj-dot-ins-process {args} {
-  proj-parse-flags args flags {
-    -touch   "" {return "-touch"}
-    -clear    0 {expr 1}
-    -validate 0 {expr 1}
-  }
-  #puts "args=$args"; parray flags
-  if {[llength $args] > 0} {
-    error "Invalid argument to [proj-scope]: $args"
-  }
-  foreach f $::proj__Config(dot-in-files) {
-    proj-assert {3==[llength $f]} \
-      "Expecting proj-dot-ins-list to be stored in 3-entry lists. Got: $f"
-    lassign $f fIn fOut fScript
-    #puts "DOING $fIn  ==> $fOut"
-    proj-make-from-dot-in {*}$flags(-touch) $fIn $fOut
-    if {$flags(-validate)} {
-      proj-validate-no-unresolved-ats $fOut
-    }
-    if {"" ne $fScript} {
-      uplevel 1 [join [list set dotInsIn $fIn \; \
-                         set dotInsOut $fOut \; \
-                         eval \{${fScript}\} \; \
-                         unset dotInsIn dotInsOut]]
-    }
-  }
-  if {$flags(-clear)} {
-    set ::proj__Config(dot-in-files) [list]
-  }
-}
-
-#
-# @proj-validate-no-unresolved-ats filenames...
-#
-# For each filename given to it, it validates that the file has no
-# unresolved @VAR@ references. If it finds any, it produces an error
-# with location information.
-#
-# Exception: if a filename matches the pattern {*[Mm]ake*} AND a given
-# line begins with a # (not including leading whitespace) then that
-# line is ignored for purposes of this validation. The intent is that
-# @VAR@ inside of makefile comments should not (necessarily) cause
-# validation to fail, as it's sometimes convenient to comment out
-# sections during development of a configure script and its
-# corresponding makefile(s).
-#
-proc proj-validate-no-unresolved-ats {args} {
-  foreach f $args {
-    set lnno 1
-    set isMake [string match {*[Mm]ake*} $f]
-    foreach line [proj-file-content-list $f] {
-      if {!$isMake || ![string match "#*" [string trimleft $line]]} {
-        if {[regexp {(@[A-Za-z0-9_\.]+@)} $line match]} {
-          error "Unresolved reference to $match at line $lnno of $f"
-        }
-      }
-      incr lnno
-    }
-  }
-}
-
-#
-# @proj-first-file-found tgtVar fileList
-#
-# Searches $fileList for an existing file. If one is found, its name
-# is assigned to tgtVar and 1 is returned, else tgtVar is set to ""
-# and 0 is returned.
-#
-proc proj-first-file-found {tgtVar fileList} {
-  upvar $tgtVar tgt
-  foreach f $fileList {
-    if {[file exists $f]} {
-      set tgt $f
-      return 1
-    }
-  }
-  set tgt ""
-  return 0
-}
-
-#
-# Defines $defName to contain makefile recipe commands for re-running
-# the configure script with its current set of $::argv flags.  This
-# can be used to automatically reconfigure.
-#
-proc proj-setup-autoreconfig {defName} {
-  define $defName \
-    [join [list \
-             cd \"$::autosetup(builddir)\" \
-             && [get-define AUTOREMAKE "error - missing @AUTOREMAKE@"]]]
-}
-
-#
-# @prop-define-append defineName args...
-#
-# A proxy for Autosetup's [define-append]. Appends all non-empty $args
-# to [define-append $defineName].
-#
-proc proj-define-append {defineName args} {
-  foreach a $args {
-    if {"" ne $a} {
-      define-append $defineName {*}$a
-    }
-  }
-}
-
-#
-# @prod-define-amend ?-p|-prepend? ?-d|-define? defineName args...
-#
-# A proxy for Autosetup's [define-append].
-#
-# Appends all non-empty $args to the define named by $defineName.  If
-# one of (-p | -prepend) are used it instead prepends them, in their
-# given order, to $defineName.
-#
-# If -define is used then each argument is assumed to be a [define]'d
-# flag and [get-define X ""] is used to fetch it.
-#
-# Re. linker flags: typically, -lXYZ flags need to be in "reverse"
-# order, with each -lY resolving symbols for -lX's to its left. This
-# order is largely historical, and not relevant on all environments,
-# but it is technically correct and still relevant on some
-# environments.
-#
-# See: proj-define-append
-#
-proc proj-define-amend {args} {
-  set defName ""
-  set prepend 0
-  set isdefs 0
-  set xargs [list]
-  foreach arg $args {
-    switch -exact -- $arg {
-      "" {}
-      -p - -prepend { incr prepend }
-      -d - -define  { incr isdefs }
-      default {
-        if {"" eq $defName} {
-          set defName $arg
-        } else {
-          lappend xargs $arg
-        }
-      }
-    }
-  }
-  if {"" eq $defName} {
-    proj-error "Missing defineName argument in call from [proj-scope 1]"
-  }
-  if {$isdefs} {
-    set args $xargs
-    set xargs [list]
-    foreach arg $args {
-      lappend xargs [get-define $arg ""]
-    }
-    set args $xargs
-  }
-#  puts "**** args=$args"
-#  puts "**** xargs=$xargs"
-
-  set args $xargs
-  if {$prepend} {
-    lappend args {*}[get-define $defName ""]
-    define $defName [join $args]; # join to eliminate {} entries
-  } else {
-    proj-define-append $defName {*}$args
-  }
-}
-
-#
-# @proj-define-to-cflag ?-list? ?-quote? ?-zero-undef? defineName...
-#
-# Treat each argument as the name of a [define] and renders it like a
-# CFLAGS value in one of the following forms:
-#
-#  -D$name
-#  -D$name=integer   (strict integer matches only)
-#  '-D$name=value'   (without -quote)
-#  '-D$name="value"' (with -quote)
-#
-# It treats integers as numbers and everything else as a quoted
-# string, noting that it does not handle strings which themselves
-# contain quotes.
-#
-# The -zero-undef flag causes no -D to be emitted for integer values
-# of 0.
-#
-# By default it returns the result as string of all -D... flags,
-# but if passed the -list flag it will return a list of the
-# individual CFLAGS.
-#
-proc proj-define-to-cflag {args} {
-  set rv {}
-  proj-parse-flags args flags {
-    -list       0 {expr 1}
-    -quote      0 {expr 1}
-    -zero-undef 0 {expr 1}
-  }
-  foreach d $args {
-    set v [get-define $d ""]
-    set li {}
-    if {"" eq $d} {
-      set v "-D${d}"
-    } elseif {[string is integer -strict $v]} {
-      if {!$flags(-zero-undef) || $v ne "0"} {
-        set v "-D${d}=$v"
-      }
-    } elseif {$flags(-quote)} {
-      set v "'-D${d}=\"$v\"'"
-    } else {
-      set v "'-D${d}=$v'"
-    }
-    lappend rv $v
-  }
-  expr {$flags(-list) ? $rv : [join $rv]}
-}
-
-
-if {0} {
-  # Turns out that autosetup's [options-add] essentially does exactly
-  # this...
-
-  # A list of lists of Autosetup [options]-format --flags definitions.
-  # Append to this using [proj-options-add] and use
-  # [proj-options-combine] to merge them into a single list for passing
-  # to [options].
-  #
-  set ::proj__Config(extra-options) {}
-
-  # @proj-options-add list
-  #
-  # Adds a list of options to the pending --flag processing.  It must be
-  # in the format used by Autosetup's [options] function.
-  #
-  # This will have no useful effect if called from after [options]
-  # is called.
-  #
-  # Use [proj-options-combine] to get a combined list of all added
-  # options.
-  #
-  # PS: when writing this i wasn't aware of autosetup's [options-add],
-  # works quite similarly. Only the timing is different.
-  proc proj-options-add {list} {
-    lappend ::proj__Config(extra-options) $list
-  }
-
-  # @proj-options-combine list1 ?...listN?
-  #
-  # Expects each argument to be a list of options compatible with
-  # autosetup's [options] function. This function concatenates the
-  # contents of each list into a new top-level list, stripping the outer
-  # list part of each argument, and returning that list
-  #
-  # If passed no arguments, it uses the list generated by calls to
-  # [proj-options-add].
-  proc proj-options-combine {args} {
-    set rv [list]
-    if {0 == [llength $args]} {
-      set args $::proj__Config(extra-options)
-    }
-    foreach e $args {
-      lappend rv {*}$e
-    }
-    return $rv
-  }
-}; # proj-options-*
-
-# Internal cache for use via proj-cache-*.
-array set proj__Cache {}
-
-#
-# @proj-cache-key arg {addLevel 0}
-#
-# Helper to generate cache keys for [proj-cache-*].
-#
-# $addLevel should almost always be 0.
-#
-# Returns a cache key for the given argument:
-#
-#   integer: relative call stack levels to get the scope name of for
-#   use as a key. [proj-scope [expr {1 + $arg + addLevel}]] is
-#   then used to generate the key. i.e. the default of 0 uses the
-#   calling scope's name as the key.
-#
-#   Anything else: returned as-is
-#
-proc proj-cache-key {arg {addLevel 0}} {
-  if {[string is integer -strict $arg]} {
-    return [proj-scope [expr {$arg + $addLevel + 1}]]
-  }
-  return $arg
-}
-
-#
-# @proj-cache-set ?-key KEY? ?-level 0? value
-#
-# Sets a feature-check cache entry with the given key.
-#
-# See proj-cache-key for -key's and -level's semantics, noting that
-# this function adds one to -level for purposes of that call.
-proc proj-cache-set {args} {
-  proj-parse-flags args flags {
-    -key => 0
-    -level => 0
-  }
-  lassign $args val
-  set key [proj-cache-key $flags(-key) [expr {1 + $flags(-level)}]]
-  #puts "** fcheck set $key = $val"
-  set ::proj__Cache($key) $val
-}
-
-#
-# @proj-cache-remove ?key? ?addLevel?
-#
-# Removes an entry from the proj-cache.
-proc proj-cache-remove {{key 0} {addLevel 0}} {
-  set key [proj-cache-key $key [expr {1 + $addLevel}]]
-  set rv ""
-  if {[info exists ::proj__Cache($key)]} {
-    set rv $::proj__Cache($key)
-    unset ::proj__Cache($key)
-  }
-  return $rv;
-}
-
-#
-# @proj-cache-check ?-key KEY? ?-level LEVEL? tgtVarName
-#
-# Checks for a feature-check cache entry with the given key.
-#
-# If the feature-check cache has a matching entry then this function
-# assigns its value to tgtVar and returns 1, else it assigns tgtVar to
-# "" and returns 0.
-#
-# See proj-cache-key for $key's and $addLevel's semantics, noting that
-# this function adds one to $addLevel for purposes of that call.
-proc proj-cache-check {args} {
-  proj-parse-flags args flags {
-    -key => 0
-    -level => 0
-  }
-  lassign $args tgtVar
-  upvar $tgtVar tgt
-  set rc 0
-  set key [proj-cache-key $flags(-key) [expr {1 + $flags(-level)}]]
-  #puts "** fcheck get key=$key"
-  if {[info exists ::proj__Cache($key)]} {
-    set tgt $::proj__Cache($key)
-    incr rc
-  } else {
-    set tgt ""
-  }
-  return $rc
-}
-
-#
-# @proj-coalesce ...args
-#
-# Returns the first argument which is not empty (eq ""), or an empty
-# string on no match.
-proc proj-coalesce {args} {
-  foreach arg $args {
-    if {"" ne $arg} {
-      return $arg
-    }
-  }
-  return ""
-}
-
-#
-# @proj-parse-flags argvListName targetArrayName {prototype}
-#
-# A helper to parse flags from proc argument lists.
-#
-# The first argument is the name of a var holding the args to
-# parse. It will be overwritten, possibly with a smaller list.
-#
-# The second argument is the name of an array variable to create in
-# the caller's scope.
-#
-# The third argument, $prototype, is a description of how to handle
-# the flags. Each entry in that list must be in one of the
-# following forms:
-#
-#   -flag  defaultValue ?-literal|-call|-apply?
-#                       script|number|incr|proc-name|{apply $aLambda}
-#
-#   -flag* ...as above...
-#
-#   -flag  => defaultValue ?-call proc-name-and-args|-apply lambdaExpr?
-#
-#   -flag* => ...as above...
-#
-#   :PRAGMA
-#
-# The first two forms represents a basic flag with no associated
-# following argument. The third and fourth forms, called arg-consuming
-# flags, extract the value from the following argument in $argvName
-# (pneumonic: => points to the next argument.). The :PRAGMA form
-# offers a way to configure certain aspects of this call.
-#
-# If $argv contains any given flag from $prototype, its default value
-# is overridden depending on several factors:
-#
-#  - If the -literal flag is used, or the flag's script is a number,
-#    value is used verbatim.
-#
-#  - Else if the -call flag is used, the argument must be a proc name
-#    and any leading arguments, e.g. {apply $myLambda}.  The proc is passed
-#    the (flag, value) as arguments (non-consuming flags will get
-#    passed the flag's current/starting value and consuming flags will
-#    get the next argument).  Its result becomes the result of the
-#    flag.
-#
-#  - Else if -apply X is used, it's effectively shorthand for -call
-#    {apply X}. Its argument may either be a $lambaRef or a {{f v}
-#    {body}} construct.
-#
-#  - Else if $script is one of the following values, it is treated as
-#    the result of...
-#
-#    - incr: increments the current value of the flag.
-#
-#  - Else $script is eval'd to get its result value. That result
-#    becomes the new flag value for $tgtArrayName(-flag). This
-#    function intercepts [return $val] from eval'ing $script.  Any
-#    empty script will result in the flag having "" assigned to it.
-#
-# Unless the -flag has a trailing asterisk, e.g. -flag*, this function
-# assumes that each flag is unique, and using a flag more than once
-# causes an error to be triggered. the -flag* forms works similarly
-# except that may appear in $argv any number of times:
-#
-#  - For non-arg-consuming flags, each invocation of -flag causes the
-#    result of $script to overwrite the previous value. e.g. so
-#    {-flag* {x} {incr foo}} has a default value of x, but passing in
-#    -flag twice would change it to the result of incrementing foo
-#    twice. This form can be used to implement, e.g., increasing
-#    verbosity levels by passing -verbose multiple times.
-#
-#  - For arg-consuming flags, the given flag starts with value X, but
-#    if the flag is provided in $argv, the default is cleared, then
-#    each instance of -flag causes its value to be appended to the
-#    result, so {-flag* => {a b c}} defaults to {a b c}, but passing
-#    in -flag y -flag z would change it to {y z}, not {a b c y z}..
-#
-# By default, the args list is only inspected until the first argument
-# which is not described by $prototype. i.e. the first "non-flag" (not
-# counting values consumed for flags defined like -flag => default).
-# The :all-flags pragma (see below) can modify this behavior.
-#
-# If a "--" flag is encountered, no more arguments are inspected as
-# flags unless the :all-flags pragma (see below) is in effect. The
-# first instance of "--" is removed from the target result list but
-# all remaining instances of "--" are are passed through.
-#
-# Any argvName entries not described in $prototype are considered to
-# be "non-flags" for purposes of this function, even if they
-# ostensibly look like flags.
-#
-# Returns the number of flags it processed in $argvName, not counting
-# "--".
-#
-# Example:
-#
-## set args [list -foo -bar {blah} -z 8 9 10 -theEnd]
-## proj-parse-flags args flags {
-##   -foo    0  {expr 1}
-##   -bar    => 0
-##   -no-baz 1  {return 0}
-##   -z 0 2
-## }
-#
-# After that $flags would contain {-foo 1 -bar {blah} -no-baz 1 -z 2}
-# and $args would be {8 9 10 -theEnd}.
-#
-# Pragmas:
-#
-# Passing :PRAGMAS to this function may modify how it works. The
-# following pragmas are supported (note the leading ":"):
-#
-#   :all-flags indicates that the whole input list should be scanned,
-#   not stopping at the first non-flag or "--".
-#
-proc proj-parse-flags {argvName tgtArrayName prototype} {
-  upvar $argvName argv
-  upvar $tgtArrayName outFlags
-  array set flags {}; # staging area
-  array set blob {}; # holds markers for various per-key state and options
-  set incrSkip 1; # 1 if we stop at the first non-flag, else 0
-  # Parse $prototype for flag definitions...
-  set n [llength $prototype]
-  set checkProtoFlag {
-    #puts "**** checkProtoFlag #$i of $n k=$k fv=$fv"
-    switch -exact -- $fv {
-      -literal {
-        proj-assert {![info exists blob(${k}.consumes)]}
-        set blob(${k}.script) [list expr [lindex $prototype [incr i]]]
-      }
-      -apply {
-        set fv [lindex $prototype [incr i]]
-        if {2 == [llength $fv]} {
-          # Treat this as a lambda literal
-          set fv [list $fv]
-        }
-        lappend blob(${k}.call) "apply $fv"
-      }
-      -call {
-        # arg is either a proc name or {apply $aLambda}
-        set fv [lindex $prototype [incr i]]
-        lappend blob(${k}.call) $fv
-      }
-      default {
-        proj-assert {![info exists blob(${k}.consumes)]}
-        set blob(${k}.script) $fv
-      }
-    }
-    if {$i >= $n} {
-      proj-error -up "[proj-scope]: Missing argument for $k flag"
-    }
-  }
-  for {set i 0} {$i < $n} {incr i} {
-    set k [lindex $prototype $i]
-    #puts "**** #$i of $n k=$k"
-
-    # Check for :PRAGMA...
-    switch -exact -- $k {
-      :all-flags {
-        set incrSkip 0
-        continue
-      }
-    }
-
-    proj-assert {[string match -* $k]} \
-      "Invalid argument: $k"
-
-    if {[string match {*\*} $k]} {
-      # Re-map -foo* to -foo and flag -foo as a repeatable flag
-      set k [string map {* ""} $k]
-      incr blob(${k}.multi)
-    }
-
-    if {[info exists flags($k)]} {
-      proj-error -up "[proj-scope]: Duplicated prototype for flag $k"
-    }
-
-    switch -exact -- [lindex $prototype [expr {$i + 1}]] {
-      => {
-        # -flag => DFLT ?-subflag arg?
-        incr i 2
-        if {$i >= $n} {
-          proj-error -up "[proj-scope]: Missing argument for $k => flag"
-        }
-        incr blob(${k}.consumes)
-        set vi [lindex $prototype $i]
-        if {$vi in {-apply -call}} {
-          proj-error -up "[proj-scope]: Missing default value for $k flag"
-        } else {
-          set fv [lindex $prototype [expr {$i + 1}]]
-          if {$fv in {-apply -call}} {
-            incr i
-            eval $checkProtoFlag
-          }
-        }
-      }
-      default {
-        # -flag VALUE ?flag? SCRIPT
-        set vi [lindex $prototype [incr i]]
-        set fv [lindex $prototype [incr i]]
-        eval $checkProtoFlag
-      }
-    }
-    #puts "**** #$i of $n k=$k vi=$vi"
-    set flags($k) $vi
-  }
-  #puts "-- flags"; parray flags
-  #puts "-- blob"; parray blob
-  set rc 0
-  set rv {}; # staging area for the target argv value
-  set skipMode 0
-  set n [llength $argv]
-  # Now look for those flags in $argv...
-  for {set i 0} {$i < $n} {incr i} {
-    set arg [lindex $argv $i]
-    #puts "-- [proj-scope] arg=$arg"
-    if {$skipMode} {
-      lappend rv $arg
-    } elseif {"--" eq $arg} {
-      # "--" is the conventional way to end processing of args
-      if {[incr blob(--)] > 1} {
-        # Elide only the first one
-        lappend rv $arg
-      }
-      incr skipMode $incrSkip
-    } elseif {[info exists flags($arg)]} {
-      # A known flag...
-      set isMulti [info exists blob(${arg}.multi)]
-      incr blob(${arg}.seen)
-      if {1 < $blob(${arg}.seen) && !$isMulti} {
-        proj-error -up [proj-scope] "$arg flag was used multiple times"
-      }
-      set vMode 0; # 0=as-is, 1=eval, 2=call
-      set isConsuming [info exists blob(${arg}.consumes)]
-      if {$isConsuming} {
-        incr i
-        if {$i >= $n} {
-          proj-error -up [proj-scope] "is missing argument for $arg flag"
-        }
-        set vv [lindex $argv $i]
-      } elseif {[info exists blob(${arg}.script)]} {
-        set vMode 1
-        set vv $blob(${arg}.script)
-      } else {
-        set vv $flags($arg)
-      }
-
-      if {[info exists blob(${arg}.call)]} {
-        set vMode 2
-        set vv [concat {*}$blob(${arg}.call) $arg $vv]
-      } elseif {$isConsuming} {
-        proj-assert {!$vMode}
-        # fall through
-      } elseif {"" eq $vv || [string is double -strict $vv]} {
-        set vMode 0
-      } elseif {$vv in {incr}} {
-        set vMode 0
-        switch -exact $vv {
-          incr {
-            set xx $flags($k); incr xx; set vv $xx; unset xx
-          }
-          default {
-            proj-error "Unhandled \$vv value $vv"
-          }
-        }
-      } else {
-        set vv [list eval $vv]
-        set vMode 1
-      }
-      if {$vMode} {
-        set code [catch [list uplevel 1 $vv] vv xopt]
-        if {$code ni {0 2}} {
-          return {*}$xopt $vv
-        }
-      }
-      if {$isConsuming && $isMulti} {
-        if {1 == $blob(${arg}.seen)} {
-          # On the first hit, overwrite the default with a new list.
-          set flags($arg) [list $vv]
-        } else {
-          # On subsequent hits, append to the list.
-          lappend flags($arg) $vv
-        }
-      } else {
-        set flags($arg) $vv
-      }
-      incr rc
-    } else {
-      # Non-flag
-      incr skipMode $incrSkip
-      lappend rv $arg
-    }
-  }
-  set argv $rv
-  array set outFlags [array get flags]
-  #puts "-- rv=$rv argv=$argv flags="; parray flags
-  return $rc
-}; # proj-parse-flags
-
-#
-# Older (deprecated) name of proj-parse-flags.
-#
-proc proj-parse-simple-flags {args} {
-  tailcall proj-parse-flags {*}$args
-}
-
-if {$::proj__Config(self-tests)} {
-  set __ova $::proj__Config(verbose-assert);
-  set ::proj__Config(verbose-assert) 1
-  puts "Running [info script] self-tests..."
-  # proj-cache...
-  apply {{} {
-    #proj-warn "Test code for proj-cache"
-    proj-assert {![proj-cache-check -key here check]}
-    proj-assert {"here" eq [proj-cache-key here]}
-    proj-assert {"" eq $check}
-    proj-cache-set -key here thevalue
-    proj-assert {[proj-cache-check -key here check]}
-    proj-assert {"thevalue" eq $check}
-
-    proj-assert {![proj-cache-check check]}
-    #puts "*** key = ([proj-cache-key 0])"
-    proj-assert {"" eq $check}
-    proj-cache-set abc
-    proj-assert {[proj-cache-check check]}
-    proj-assert {"abc" eq $check}
-
-    #parray ::proj__Cache;
-    proj-assert {"" ne [proj-cache-remove]}
-    proj-assert {![proj-cache-check check]}
-    proj-assert {"" eq [proj-cache-remove]}
-    proj-assert {"" eq $check}
-  }}
-
-  # proj-parse-flags ...
-  apply {{} {
-    set foo 3
-    set argv {-a "hi - world" -b -b -b -- -a {bye bye} -- -d -D c -a "" --}
-    proj-parse-flags argv flags {
-      :all-flags
-      -a* => "gets overwritten"
-      -b* 7 {incr foo}
-      -d 1 0
-      -D 0 1
-    }
-
-    #puts "-- argv = $argv"; parray flags;
-    proj-assert {"-- c --" eq $argv}
-    proj-assert {$flags(-a) eq "{hi - world} {bye bye} {}"}
-    proj-assert {$foo == 6}
-    proj-assert {$flags(-b) eq $foo}
-    proj-assert {$flags(-d) == 0}
-    proj-assert {$flags(-D) == 1}
-    set foo 0
-    foreach x $flags(-a) {
-      proj-assert {$x in {{hi - world} {bye bye} {}}}
-      incr foo
-    }
-    proj-assert {3 == $foo}
-
-    set argv {-a {hi world} -b -maybe -- -a {bye bye} -- -b c --}
-    set foo 0
-    proj-parse-flags argv flags {
-      -a => "aaa"
-      -b 0 {incr foo}
-      -maybe no -literal yes
-    }
-    #parray flags; puts "--- argv = $argv"
-    proj-assert {"-a {bye bye} -- -b c --" eq $argv}
-    proj-assert {$flags(-a) eq "hi world"}
-    proj-assert {1 == $flags(-b)}
-    proj-assert {"yes" eq $flags(-maybe)}
-
-    set argv {-f -g -a aaa -M -M -M -L -H -A AAA a b c}
-    set foo 0
-    set myLambda {{flag val} {
-      proj-assert {$flag in {-f -g -M}}
-      #puts "myLambda flag=$flag val=$val"
-      incr val
-    }}
-    proc myNonLambda {flag val} {
-      proj-assert {$flag in {-A -a}}
-      #puts "myNonLambda flag=$flag val=$val"
-      concat $val $val
-    }
-    proj-parse-flags argv flags {
-      -f 0 -call {apply $myLambda}
-      -g 2 -apply $myLambda
-      -h 3 -apply $myLambda
-      -H 30 33
-      -a => aAAAa -apply {{f v} {
-        set v
-      }}
-      -A => AaaaA -call myNonLambda
-      -B => 17 -call myNonLambda
-      -M* 0 -apply $myLambda
-      -L "" -literal $myLambda
-    }
-    rename myNonLambda ""
-    #puts "--- argv = $argv"; parray flags
-    proj-assert {$flags(-f) == 1}
-    proj-assert {$flags(-g) == 3}
-    proj-assert {$flags(-h) == 3}
-    proj-assert {$flags(-H) == 33}
-    proj-assert {$flags(-a) == {aaa}}
-    proj-assert {$flags(-A) eq "AAA AAA"}
-    proj-assert {$flags(-B) == 17}
-    proj-assert {$flags(-M) == 3}
-    proj-assert {$flags(-L) eq $myLambda}
-
-    set argv {-touch -validate}
-    proj-parse-flags argv flags {
-      -touch "" {return "-touch"}
-      -validate 0 1
-    }
-    #puts "----- argv = $argv"; parray flags
-    proj-assert {$flags(-touch) eq "-touch"}
-    proj-assert {$flags(-validate) == 1}
-    proj-assert {$argv eq {}}
-
-    set argv {-i -i -i}
-    proj-parse-flags argv flags {
-      -i* 0 incr
-    }
-    proj-assert {3 == $flags(-i)}
-  }}
-  set ::proj__Config(verbose-assert) $__ova
-  unset __ova
-  puts "Done running [info script] self-tests."
-}; # proj- API self-tests
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/sqlite-config.tcl b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/sqlite-config.tcl
deleted file mode 100644
index 59ecb71..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/sqlite-config.tcl
+++ /dev/null
@@ -1,2279 +0,0 @@
-# This file holds functions for autosetup which are specific to the
-# sqlite build tree.  They are in this file, instead of auto.def, so
-# that they can be reused in the autoconf sub-tree. This file requires
-# functions from the project-agnostic proj.tcl.
-
-if {[string first " " $autosetup(srcdir)] != -1} {
-  user-error "The pathname of the source tree\
-              may not contain space characters"
-}
-if {[string first " " $autosetup(builddir)] != -1} {
-  user-error "The pathname of the build directory\
-              may not contain space characters"
-}
-
-use proj
-#
-# We want the package version info to be emitted early on, but doing
-# so requires a bit of juggling. We have to [use system] for
-# --prefix=... to work and to emit the Host/Build system info, but we
-# don't want those to interfere with --help output.
-define PACKAGE_VERSION [proj-file-content -trim $::autosetup(srcdir)/VERSION]
-if {"--help" ni $::argv} {
-  msg-result "Configuring SQLite version [get-define PACKAGE_VERSION]"
-}
-use system ; # Will output "Host System" and "Build System" lines
-if {"--help" ni $::argv} {
-  proj-tweak-default-env-dirs
-  msg-result "Source dir = $::autosetup(srcdir)"
-  msg-result "Build dir  = $::autosetup(builddir)"
-  use cc cc-db cc-shared cc-lib pkg-config
-}
-
-#
-# Object for communicating certain config-time state across various
-# auto.def-related pieces.
-array set sqliteConfig [subst [proj-strip-hash-comments {
-  #
-  # Gets set by [sqlite-configure] (the main configure script driver).
-  build-mode unknown
-  #
-  # Gets set to 1 when using jimsh for code generation. May affect
-  # later decisions.
-  use-jim-for-codegen  0
-  #
-  # Set to 1 when cross-compiling This value may be changed by certain
-  # build options, so it's important that config code which checks for
-  # cross-compilation uses this var instead of
-  # [proj-is-cross-compiling].
-  is-cross-compiling [proj-is-cross-compiling]
-  #
-  # Pass msg-debug=1 to configure to enable obnoxiously loud output
-  # from [msg-debug].
-  msg-debug-enabled    0
-  #
-  # Output file for --dump-defines. Intended only for build debugging
-  # and not part of the public build interface.
-  dump-defines-txt   ./config.defines.txt
-  #
-  # If not empty then --dump-defines will dump not only
-  # (dump-defines-txt) but also a JSON file named after this option's
-  # value.
-  dump-defines-json  ""
-
-  #
-  # The list of feature --flags which the --all flag implies. This
-  # requires special handling in a few places.
-  #
-  all-flag-enables {fts4 fts5 rtree geopoly session dbpage dbstat carray}
-
-  #
-  # Default value for the --all flag. Can hypothetically be modified
-  # by non-canonical builds (it was added for a Tcl extension build
-  # mode which was eventually removed).
-  #
-  all-flag-default 0
-}]]
-
-########################################################################
-# Processes all configure --flags for this build, run build-specific
-# config checks, then finalize the configure process. $buildMode must
-# be one of (canonical, autoconf), and others may be added in the
-# future. After bootstrapping, $configScript is eval'd in the caller's
-# scope, then post-configuration finalization is run. $configScript is
-# intended to hold configure code which is specific to the given
-# $buildMode, with the caveat that _some_ build-specific code is
-# encapsulated in the configuration finalization step.
-#
-# The intent is that all (or almost all) build-mode-specific
-# configuration goes inside the $configScript argument to this
-# function, and that an auto.def file contains only two commands:
-#
-#  use sqlite-config
-#  sqlite-configure BUILD_NAME { build-specific configure script }
-#
-# There are snippets of build-mode-specific decision-making in
-# [sqlite-configure-finalize], which gets run after $configScript.
-proc sqlite-configure {buildMode configScript} {
-  proj-assert {$::sqliteConfig(build-mode) eq "unknown"} \
-    "sqlite-configure must not be called more than once"
-  set allBuildModes {canonical autoconf}
-  if {$buildMode ni $allBuildModes} {
-    user-error "Invalid build mode: $buildMode. Expecting one of: $allBuildModes"
-  }
-  if {$::sqliteConfig(all-flag-default)} {
-    set allFlagHelp "Disable these extensions: $::sqliteConfig(all-flag-enables)"
-  } else {
-    set allFlagHelp "Enable these extensions: $::sqliteConfig(all-flag-enables)"
-  }
-
-  set ::sqliteConfig(build-mode) $buildMode
-  ########################################################################
-  # A gentle introduction to flags handling in autosetup
-  #
-  # Reference: https://msteveb.github.io/autosetup/developer/
-  #
-  # All configure flags must be described in one or more calls to
-  # autosetup's [options] and [options-add] functions. The general
-  # syntax of the single argument to those functions is a list contain
-  # a mapping of flags to help text:
-  #
-  #  FLAG => {Help text}
-  #
-  # Where FLAG can have any of the following formats:
-  #
-  #   boolopt            => "a boolean option which defaults to disabled"
-  #   boolopt2=1         => "a boolean option which defaults to enabled"
-  #   stringopt:         => "an option which takes an argument, e.g. --stringopt=value"
-  #   stringopt:DESCR    => As for stringopt: with a description for the value
-  #   stringopt2:=value  => "an option where the argument is optional and defaults to 'value'"
-  #   optalias booltopt3 => "a boolean with a hidden alias. --optalias is not shown in --help"
-  #
-  # Autosetup does no small amount of specialized handling for flags,
-  # especially booleans. Each bool-type --FLAG implicitly gets
-  # --enable-FLAG and --disable-FLAG forms. That can lead lead to some
-  # confusion when writing help text. For example:
-  #
-  #   options { json=1 {Disable JSON functions} }
-  #
-  # The reason the help text says "disable" is because a boolean option
-  # which defaults to true is, in the --help text, rendered as:
-  #
-  #   --disable-json          Disable JSON functions
-  #
-  # Whereas a bool flag which defaults to false will instead render as:
-  #
-  #   --enable-FLAG
-  #
-  # Non-boolean flags, in contrast, use the names specifically given to
-  # them in the [options] invocation. e.g. "with-tcl" is the --with-tcl
-  # flag.
-  #
-  # Fetching values for flags:
-  #
-  #   booleans: use one of:
-  #     - [opt-bool FLAG] is autosetup's built-in command for this, but we
-  #       have some convenience variants:
-  #     - [proj-opt-truthy FLAG]
-  #     - [proj-opt-if-truthy FLAG {THEN} {ELSE}]
-  #
-  #   Non-boolean (i.e. string) flags:
-  #     - [opt-val FLAG ?default?]
-  #     - [opt-str ...] - see the docs in ./autosetup/autosetup
-  #
-  # [proj-opt-was-provided] can be used to determine whether a flag was
-  # explicitly provided, which is often useful for distinguishing from
-  # the case of a default value.
-  ########################################################################
-  set allFlags {
-    # Structure: a list of M {Z} pairs, where M is a descriptive
-    # option group name and Z is a list of X Y pairs. X is a list of
-    # $buildMode name(s) to which the Y flags apply, or {*} to apply
-    # to all builds. Y is a {block} in the form expected by
-    # autosetup's [options] and [options-add] command.  Each block
-    # which is applicable to $buildMode is passed on to
-    # [options-add]. The order of each Y and sub-Y is retained, which
-    # is significant for rendering of --help.
-    #
-    # Maintenance note: [options] does not support comments in
-    # options, but we filter this object through
-    # [proj-strip-hash-comments] to remove them before passing them on
-    # to [options].
-
-    # When writing {help text blocks}, be aware that:
-    #
-    # A) autosetup formats them differently if the {block} starts with
-    # a newline: it starts left-aligned, directly under the --flag, and
-    # the rest of the block is pasted verbatim rather than
-    # pretty-printed.
-    #
-    # B) Vars and commands are NOT expanded, but we use a [subst] call
-    # below which will replace (only) $var refs.
-
-    # Options for how to build the library
-    build-modes {
-      {canonical autoconf} {
-        shared=1             => {Disable build of shared library}
-        static=1             => {Disable build of static library}
-      }
-      {canonical} {
-        amalgamation=1       => {Disable the amalgamation and instead build all files separately}
-      }
-    }
-
-    # Library-level features and defaults
-    lib-features {
-      {*} {
-        threadsafe=1         => {Disable mutexing}
-        with-tempstore:=no   => {Use an in-RAM database for temporary tables: never,no,yes,always}
-        load-extension=1     => {Disable loading of external extensions}
-        # ^^^ one of the downstream custom builds overrides the load-extension default to 0, which
-        # confuses the --help text generator. https://github.com/msteveb/autosetup/issues/77
-        math=1               => {Disable math functions}
-        json=1               => {Disable JSON functions}
-        memsys5              => {Enable MEMSYS5}
-        memsys3              => {Enable MEMSYS3}
-        fts3                 => {Enable the FTS3 extension}
-        fts4                 => {Enable the FTS4 extension}
-        fts5                 => {Enable the FTS5 extension}
-        update-limit         => {Enable the UPDATE/DELETE LIMIT clause}
-        geopoly              => {Enable the GEOPOLY extension}
-        rtree                => {Enable the RTREE extension}
-        session              => {Enable the SESSION extension}
-        dbpage               => {Enable the sqlite3_dbpage extension}
-        dbstat               => {Enable the sqlite3_dbstat extension}
-        carray=1             => {Disable the CARRAY extension}
-        all=$::sqliteConfig(all-flag-default) => {$allFlagHelp}
-        largefile=1
-          => {This legacy flag has no effect on the library but may influence
-              the generated sqlite_cfg.h by adding #define HAVE_LFS}
-      }
-      {canonical} {
-        column-metadata      => {Enable the column metadata APIs}
-        # ^^^ Affects how sqlite3.c is generated, so is not available in
-        # the autoconf build.
-      }
-    }
-
-    # Options for TCL support
-    tcl {
-      {canonical} {
-        tcl=1
-          => {Disable components which require TCL, including all tests.
-              This tree requires TCL for code generation but can use the in-tree
-              copy of autosetup/jimsh0.c for that. The SQLite TCL extension and the
-              test code require a canonical tclsh.}
-        with-tcl:DIR
-          => {Directory containing tclConfig.sh or a directory one level up from
-              that, from which we can derive a directory containing tclConfig.sh.
-              A dir name of "prefix" is equivalent to the directory specified by
-              the --prefix flag.}
-        with-tclsh:PATH
-          => {Full pathname of tclsh to use.  It is used for (A) trying to find
-              tclConfig.sh and (B) all TCL-based code generation. Use --with-tcl
-              unless you have a specific need for this flag. Warning: if its
-              containing dir has multiple tclsh versions, it may select the
-              wrong tclConfig.sh!}
-        static-tclsqlite3=0
-          => {Statically-link tclsqlite3. This only works if TCL support is
-              enabled and all requisite libraries are available in
-              static form. Note that glibc is unable to fully statically
-              link certain libraries required by tclsqlite3, so this won't
-              work on most Linux environments.}
-      }
-    }
-
-    # Options for line-editing modes for the CLI shell
-    line-editing {
-      {canonical autoconf} {
-        readline=1
-          => {Disable readline support}
-        # --with-readline-lib is a backwards-compatible alias for
-        # --with-readline-ldflags
-        with-readline-lib:
-        with-readline-ldflags:=auto
-          => {Readline LDFLAGS, e.g. -lreadline -lncurses}
-        # --with-readline-inc is a backwards-compatible alias for
-        # --with-readline-cflags.
-        with-readline-inc:
-        with-readline-cflags:=auto
-          => {Readline CFLAGS, e.g. -I/path/to/includes}
-        with-readline-header:PATH
-          => {Full path to readline.h, from which --with-readline-cflags will be derived}
-        with-linenoise:DIR
-          => {Source directory for linenoise.c and linenoise.h}
-        editline=0
-          => {Enable BSD editline support}
-      }
-    }
-
-    # Options for ICU: International Components for Unicode
-    icu {
-      {*} {
-        with-icu-ldflags:LDFLAGS
-          => {Enable SQLITE_ENABLE_ICU and add the given linker flags for the
-              ICU libraries. e.g. on Ubuntu systems, try '-licui18n -licuuc -licudata'.}
-        with-icu-cflags:CFLAGS
-          => {Apply extra CFLAGS/CPPFLAGS necessary for building with ICU.
-              e.g. -I/usr/local/include}
-        with-icu-config:=auto
-          => {Enable SQLITE_ENABLE_ICU. Value must be one of: auto, pkg-config,
-              /path/to/icu-config}
-        icu-collations=0
-          => {Enable SQLITE_ENABLE_ICU_COLLATIONS. Requires --with-icu-ldflags=...
-              or --with-icu-config}
-      }
-    }
-
-    # Options for exotic/alternative build modes
-    alternative-builds {
-      {canonical autoconf} {
-        with-wasi-sdk:=/opt/wasi-sdk
-          => {Top-most dir of the wasi-sdk for a WASI build}
-      }
-
-      {*} {
-        # Note that --static-cli-shell has a completely different
-        # meaning from --static-shell in the autoconf build!
-        # --[disable-]static-shell is a legacy flag which we can't
-        # remove without breaking downstream builds.
-        static-cli-shell=0
-          => {Statically-link the sqlite3 CLI shell.
-              This only works if the requisite libraries are all available in
-              static form.}
-      }
-
-      {canonical} {
-        static-shells=0
-          => {Shorthand for --static-cli-shell --static-tclsqlite3}
-
-        with-emsdk:=auto
-          => {Top-most dir of the Emscripten SDK installation.
-              Needed only by ext/wasm. Default=EMSDK env var.}
-
-        amalgamation-extra-src:FILES
-          => {Space-separated list of source files to append as-is to the resulting
-              sqlite3.c amalgamation file. May be provided multiple times.}
-      }
-    }
-
-    # Options primarily for downstream packagers/package maintainers
-    packaging {
-      {autoconf} {
-        # --disable-static-shell: https://sqlite.org/forum/forumpost/cc219ee704
-        # Note that this has a different meaning from --static-cli-shell in the
-        # canonical build!
-        static-shell=1
-          => {Link the sqlite3 shell app against the DLL instead of embedding sqlite3.c}
-      }
-      {canonical autoconf} {
-        rpath=1 => {Disable use of the rpath linker flag}
-        # soname: https://sqlite.org/src/forumpost/5a3b44f510df8ded
-        soname:=legacy
-          => {SONAME for libsqlite3.so. "none", or not using this flag, sets no
-              soname. "legacy" sets it to its historical value of
-              libsqlite3.so.0.  A value matching the glob "libsqlite3.*" sets
-              it to that literal value. Any other value is assumed to be a
-              suffix which gets applied to "libsqlite3.so.",
-              e.g. --soname=9.10 equates to "libsqlite3.so.9.10".}
-        # dll-basename: https://sqlite.org/forum/forumpost/828fdfe904
-        dll-basename:=auto
-          => {Specifies the base name of the resulting DLL file.
-              If not provided, "libsqlite3" is usually assumed but on some platforms
-              a platform-dependent default is used. On some platforms this flag
-              gets automatically enabled if it is not provided. Use "default" to
-              explicitly disable platform-dependent activation on such systems.}
-        # out-implib: https://sqlite.org/forum/forumpost/0c7fc097b2
-        out-implib:=auto
-          => {Enable use of --out-implib linker flag to generate an
-              "import library" for the DLL. The output's base name is
-              specified by this flag's value, with "auto" meaning to figure
-              out a name automatically. On some platforms this flag gets
-              automatically enabled if it is not provided. Use "none" to
-              explicitly disable this feature on such platforms.}
-      }
-    }
-
-    # Options mostly for sqlite's own development
-    developer {
-      {*} {
-        # Note that using the --debug/--enable-debug flag here
-        # requires patching autosetup/autosetup to rename its builtin
-        # --debug to --autosetup-debug. See details in
-        # autosetup/README.md#patching.
-        with-debug=0
-        debug=0
-          => {Enable debug build flags. This option will impact performance by
-              as much as 4x, as it includes large numbers of assert()s in
-              performance-critical loops.  Never use --debug for production
-              builds.}
-        scanstatus
-          => {Enable the SQLITE_ENABLE_STMT_SCANSTATUS feature flag}
-      }
-      {canonical} {
-        dev
-          => {Enable dev-mode build: automatically enables certain other flags}
-        test-status
-          => {Enable status of tests}
-        gcov=0
-          => {Enable coverage testing using gcov}
-        linemacros
-          => {Enable #line macros in the amalgamation}
-        dynlink-tools
-          => {Dynamically link libsqlite3 to certain tools which normally statically embed it}
-        asan-fsanitize:=auto
-          => {Comma- or space-separated list of -fsanitize flags for use with the
-              fuzzcheck-asan tool. Only those which the compiler claims to support
-              will actually be used. May be provided multiple times.}
-      }
-      {*} {
-        dump-defines=0
-          => {Dump autosetup defines to $::sqliteConfig(dump-defines-txt)
-              (for build debugging)}
-      }
-    }
-  }; # $allFlags
-
-  set allFlags [proj-strip-hash-comments $allFlags]
-  # ^^^ lappend of [sqlite-custom-flags] introduces weirdness if
-  # we delay [proj-strip-hash-comments] until after that.
-
-  ########################################################################
-  # sqlite-custom.tcl is intended only for vendor-branch-specific
-  # customization.  See autosetup/README.md#branch-customization for
-  # details.
-  if {[file exists $::autosetup(libdir)/sqlite-custom.tcl]} {
-    uplevel 1 {source $::autosetup(libdir)/sqlite-custom.tcl}
-  }
-
-  if {[llength [info proc sqlite-custom-flags]] > 0} {
-    # sqlite-custom-flags is assumed to be imported via
-    # autosetup/sqlite-custom.tcl.
-    set scf [sqlite-custom-flags]
-    if {"" ne $scf} {
-      lappend allFlags sqlite-custom-flags $scf
-    }
-  }
-
-  #lappend allFlags just-testing {{*} {soname:=duplicateEntry => {x}}}
-
-  # Filter allFlags to create the set of [options] legal for this build
-  foreach {group XY} [subst -nobackslashes -nocommands $allFlags] {
-    foreach {X Y} $XY {
-      if { $buildMode in $X || "*" in $X } {
-        options-add $Y
-      }
-    }
-  }
-
-  if {[catch {options {}} msg xopts]} {
-    # Workaround for <https://github.com/msteveb/autosetup/issues/73>
-    # where [options] behaves oddly on _some_ TCL builds when it's
-    # called from deeper than the global scope.
-    dict incr xopts -level
-    return {*}$xopts $msg
-  }
-  sqlite-configure-phase1 $buildMode
-  uplevel 1 $configScript
-  sqlite-configure-finalize
-}; # sqlite-configure
-
-########################################################################
-# Runs "phase 1" of the configure process: after initial --flags
-# handling but before sqlite-configure's $configScript argument is
-# run. $buildMode must be the mode which was passed to
-# [sqlite-configure].
-proc sqlite-configure-phase1 {buildMode} {
-  define PACKAGE_NAME sqlite
-  define PACKAGE_URL {https://sqlite.org}
-  define PACKAGE_BUGREPORT [get-define PACKAGE_URL]/forum
-  define PACKAGE_STRING "[get-define PACKAGE_NAME] [get-define PACKAGE_VERSION]"
-  proj-xfer-options-aliases {
-    # Carry values from hidden --flag aliases over to their canonical
-    # flag forms. This list must include only options which are common
-    # to all build modes supported by [sqlite-configure].
-    with-readline-inc => with-readline-cflags
-    with-readline-lib => with-readline-ldflags
-    with-debug => debug
-  }
-  set ::sqliteConfig(msg-debug-enabled) [proj-val-truthy [get-env msg-debug 0]]
-  proc-debug "msg-debug is enabled"
-  proj-setup-autoreconfig SQLITE_AUTORECONFIG
-  proj-file-extensions
-  if {".exe" eq [get-define TARGET_EXEEXT]} {
-    define SQLITE_OS_UNIX 0
-    define SQLITE_OS_WIN 1
-  } else {
-    define SQLITE_OS_UNIX 1
-    define SQLITE_OS_WIN 0
-  }
-  sqlite-setup-default-cflags
-  define HAVE_LFS 0
-  if {[opt-bool largefile]} {
-    #
-    # Insofar as we can determine HAVE_LFS has no effect on the
-    # library.  Perhaps it did back in the early 2000's. The
-    # --enable/disable-largefile flag is retained because it's
-    # harmless, but it doesn't do anything useful. It does have
-    # visible side-effects, though: the generated sqlite_cfg.h may (or
-    # may not) define HAVE_LFS.
-    cc-check-lfs
-  }
-  set srcdir $::autosetup(srcdir)
-  proj-dot-ins-append $srcdir/Makefile.in
-  if {[file exists $srcdir/sqlite3.pc.in]} {
-    proj-dot-ins-append $srcdir/sqlite3.pc.in
-  }
-  sqlite-handle-hpux; # must be relatively early so that other config tests can work
-}; # sqlite-configure-phase1
-
-########################################################################
-# Performs late-stage config steps common to all supported
-# $::sqliteConfig(build-mode) values.
-proc sqlite-configure-finalize {} {
-  sqlite-handle-rpath
-  sqlite-handle-soname
-  sqlite-handle-threadsafe
-  sqlite-handle-tempstore
-  sqlite-handle-load-extension
-  sqlite-handle-math
-  sqlite-handle-icu
-  if {[proj-opt-exists readline]} {
-    sqlite-handle-line-editing
-  }
-  if {[proj-opt-exists shared]} {
-    proj-define-for-opt shared ENABLE_LIB_SHARED "Build shared library?"
-  }
-  if {[proj-opt-exists static]} {
-    if {![proj-define-for-opt static ENABLE_LIB_STATIC "Build static library?"]} {
-      # This notice really only applies to the canonical build...
-      proj-indented-notice {
-        NOTICE: static lib build may be implicitly re-activated by
-        other components, e.g. some test apps.
-      }
-    }
-  }
-  sqlite-handle-env-quirks
-  sqlite-handle-common-feature-flags
-  sqlite-finalize-feature-flags
-  sqlite-process-dot-in-files; # do not [define] anything after this
-  sqlite-dump-defines
-}
-
-########################################################################
-# Internal config-time debugging output routine. It generates no
-# output unless msg-debug=1 is passed to the configure script.
-proc msg-debug {msg} {
-  if {$::sqliteConfig(msg-debug-enabled)} {
-    puts stderr [proj-bold "** DEBUG: $msg"]
-  }
-}
-########################################################################
-# A [msg-debug] proxy which prepends the name of the current proc to
-# the debug message. It is not legal to call this from the global
-# scope.
-proc proc-debug {msg} {
-  msg-debug "\[[proj-scope 1]\]: $msg"
-}
-
-define OPT_FEATURE_FLAGS {} ; # -DSQLITE_OMIT/ENABLE flags.
-#
-# OPT_SHELL = feature-related CFLAGS for the sqlite3 CLI app. The
-# list's initial values are defaults which are always applied and not
-# affected by --feature-flags. The list is appended to by various
-# --feature-flags.
-define OPT_SHELL {
-  -DSQLITE_DQS=0
-  -DSQLITE_ENABLE_FTS4
-  -DSQLITE_ENABLE_RTREE
-  -DSQLITE_ENABLE_EXPLAIN_COMMENTS
-  -DSQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
-  -DSQLITE_ENABLE_STMTVTAB
-  -DSQLITE_ENABLE_DBPAGE_VTAB
-  -DSQLITE_ENABLE_DBSTAT_VTAB
-  -DSQLITE_ENABLE_BYTECODE_VTAB
-  -DSQLITE_ENABLE_OFFSET_SQL_FUNC
-  -DSQLITE_ENABLE_PERCENTILE
-  -DSQLITE_STRICT_SUBTYPE=1
-}
-########################################################################
-# Adds $args, if not empty, to OPT_FEATURE_FLAGS.  If the first arg is
-# -shell then it strips that arg and passes the remaining args the
-# sqlite-add-shell-opt in addition to adding them to
-# OPT_FEATURE_FLAGS. This is intended only for holding
-# -DSQLITE_ENABLE/OMIT/... flags, but that is not enforced here.
-proc sqlite-add-feature-flag {args} {
-  set shell ""
-  if {"-shell" eq [lindex $args 0]} {
-    set args [lassign $args shell]
-  }
-  if {"" ne $args} {
-    if {"" ne $shell} {
-      sqlite-add-shell-opt {*}$args
-    }
-    define-append OPT_FEATURE_FLAGS {*}$args
-  }
-}
-
-########################################################################
-# Appends $args, if not empty, to OPT_SHELL.
-proc sqlite-add-shell-opt {args} {
-  if {"" ne $args} {
-    define-append OPT_SHELL {*}$args
-  }
-}
-
-########################################################################
-# Check for log(3) in libm and die with an error if it is not
-# found. $featureName should be the feature name which requires that
-# function (it's used only in error messages). defines LDFLAGS_MATH to
-# the required linker flags (which may be empty even if the math APIs
-# are found, depending on the OS).
-proc sqlite-affirm-have-math {featureName} {
-  if {"" eq [get-define LDFLAGS_MATH ""]} {
-    if {![msg-quiet proj-check-function-in-lib log m]} {
-      user-error "Missing math APIs for $featureName"
-    }
-    set lfl [get-define lib_log ""]
-    undefine lib_log
-    if {"" ne $lfl} {
-      user-notice "Forcing requirement of $lfl for $featureName"
-    }
-    define LDFLAGS_MATH $lfl
-  }
-}
-
-########################################################################
-# Run checks for required binaries, like ld and ar. In the canonical
-# build this must come before [sqlite-handle-wasi-sdk].
-proc sqlite-check-common-bins {} {
-  cc-check-tools ld ar ; # must come before [sqlite-handle-wasi-sdk]
-  if {"" eq [proj-bin-define install]} {
-    proj-warn "Cannot find install binary, so 'make install' will not work."
-    define BIN_INSTALL false
-  }
-}
-
-########################################################################
-# Run checks for system-level includes and libs which are common to
-# both the canonical build and the "autoconf" bundle.
-#
-# For the canonical build this must come after
-# [sqlite-handle-wasi-sdk], as that function may change the
-# environment in ways which affect this.
-proc sqlite-check-common-system-deps {} {
-  # Check for needed/wanted data types
-  cc-with {-includes stdint.h} \
-    {cc-check-types int8_t int16_t int32_t int64_t intptr_t \
-       uint8_t uint16_t uint32_t uint64_t uintptr_t}
-
-  # Check for needed/wanted functions
-  cc-check-functions gmtime_r isnan localtime_r localtime_s \
-    usleep utime pread pread64 pwrite pwrite64
-
-  apply {{} {
-    set ldrt ""
-    # Collapse funcs from librt into LDFLAGS_RT.
-    # Some systems (ex: SunOS) require -lrt in order to use nanosleep
-    foreach func {fdatasync nanosleep} {
-      if {[proj-check-function-in-lib $func rt]} {
-        set ldrt [get-define lib_${func} ""]
-        undefine lib_${func}
-        if {"" ne $ldrt} {
-          break
-        }
-      }
-    }
-    define LDFLAGS_RT $ldrt
-  }}
-
-  # Check for needed/wanted headers
-  cc-check-includes \
-    sys/types.h sys/stat.h dlfcn.h unistd.h \
-    stdlib.h malloc.h memory.h \
-    string.h strings.h \
-    inttypes.h
-
-  if {[cc-check-includes zlib.h] && [proj-check-function-in-lib deflate z]} {
-    # TODO? port over the more sophisticated zlib search from the fossil auto.def
-    define HAVE_ZLIB 1
-    define LDFLAGS_ZLIB -lz
-    sqlite-add-shell-opt -DSQLITE_HAVE_ZLIB=1
-    sqlite-add-feature-flag -DSQLITE_HAVE_ZLIB=1
-  } else {
-    define HAVE_ZLIB 0
-    define LDFLAGS_ZLIB ""
-  }
-}
-
-########################################################################
-# Move -DSQLITE_OMIT... and -DSQLITE_ENABLE... flags from CFLAGS and
-# CPPFLAGS to OPT_FEATURE_FLAGS and remove them from BUILD_CFLAGS.
-proc sqlite-munge-cflags {} {
-  # Move CFLAGS and CPPFLAGS entries matching -DSQLITE_OMIT* and
-  # -DSQLITE_ENABLE* to OPT_FEATURE_FLAGS. This behavior is derived
-  # from the legacy build and was missing the 3.48.0 release (the
-  # initial Autosetup port).
-  # https://sqlite.org/forum/forumpost/9801e54665afd728
-  #
-  # Handling of CPPFLAGS, as well as removing ENABLE/OMIT from
-  # CFLAGS/CPPFLAGS, was missing in the 3.49.0 release as well.
-  #
-  # If any configure flags for features are in conflict with
-  # CFLAGS/CPPFLAGS-specified feature flags, all bets are off.  There
-  # are no guarantees about which one will take precedence.
-  foreach flagDef {CFLAGS CPPFLAGS} {
-    set tmp ""
-    foreach cf [get-define $flagDef ""] {
-      switch -glob -- $cf {
-        -DSQLITE_OMIT* -
-        -DSQLITE_ENABLE* {
-          sqlite-add-feature-flag $cf
-        }
-        default {
-          lappend tmp $cf
-        }
-      }
-    }
-    define $flagDef $tmp
-  }
-
-  # Strip all SQLITE_ENABLE/OMIT flags from BUILD_CFLAGS,
-  # for compatibility with the legacy build.
-  set tmp ""
-  foreach cf [get-define BUILD_CFLAGS ""] {
-    switch -glob -- $cf {
-      -DSQLITE_OMIT* -
-      -DSQLITE_ENABLE* {}
-      default {
-        lappend tmp $cf
-      }
-    }
-  }
-  define BUILD_CFLAGS $tmp
-}
-
-#########################################################################
-# Set up the default CFLAGS and BUILD_CFLAGS values.
-proc sqlite-setup-default-cflags {} {
-  ########################################################################
-  # We differentiate between two C compilers: the one used for binaries
-  # which are to run on the build system (in autosetup it's called
-  # CC_FOR_BUILD and in Makefile.in it's $(B.cc)) and the one used for
-  # compiling binaries for the target system (CC a.k.a. $(T.cc)).
-  # Normally they're the same, but they will differ when
-  # cross-compiling.
-  set defaultCFlags {-O2}
-  if {!$::sqliteConfig(is-cross-compiling)} {
-    # When cross-compiling we default to not using the -g flag, based
-    # on a /chat discussion prompted by
-    # https://sqlite.org/forum/forumpost/9a67df63eda9925c
-    lappend defaultCFlags -g
-  }
-  define CFLAGS [proj-get-env CFLAGS $defaultCFlags]
-  # BUILD_CFLAGS is the CFLAGS for CC_FOR_BUILD.
-  define BUILD_CFLAGS [proj-get-env BUILD_CFLAGS {-g}]
-  sqlite-munge-cflags
-}
-
-########################################################################
-# Handle various SQLITE_ENABLE/OMIT_... feature flags.
-proc sqlite-handle-common-feature-flags {} {
-  msg-result "Feature flags..."
-  if {![opt-bool all]} {
-    # Special handling for --disable-all
-    foreach flag $::sqliteConfig(all-flag-enables) {
-      if {![proj-opt-was-provided $flag]} {
-        proj-opt-set $flag 0
-      }
-    }
-  }
-  foreach {boolFlag featureFlag ifSetEvalThis} [proj-strip-hash-comments {
-    all         {} {
-      # The 'all' option must be first in this list.  This impl makes
-      # an effort to only apply flags which the user did not already
-      # apply, so that combinations like (--all --disable-geopoly)
-      # will indeed disable geopoly. There are corner cases where
-      # flags which depend on each other will behave in non-intuitive
-      # ways:
-      #
-      # --all --disable-rtree
-      #
-      # Will NOT disable geopoly, though geopoly depends on rtree.
-      # The --geopoly flag, though, will automatically re-enable
-      # --rtree, so --disable-rtree won't actually disable anything in
-      # that case.
-      foreach k $::sqliteConfig(all-flag-enables) {
-        if {![proj-opt-was-provided $k]} {
-          proj-opt-set $k 1
-        }
-      }
-    }
-    fts3         -DSQLITE_ENABLE_FTS3    {sqlite-affirm-have-math fts3}
-    fts4         -DSQLITE_ENABLE_FTS4    {sqlite-affirm-have-math fts4}
-    fts5         -DSQLITE_ENABLE_FTS5    {sqlite-affirm-have-math fts5}
-    geopoly      -DSQLITE_ENABLE_GEOPOLY {proj-opt-set rtree}
-    rtree        -DSQLITE_ENABLE_RTREE   {}
-    session      {-DSQLITE_ENABLE_SESSION -DSQLITE_ENABLE_PREUPDATE_HOOK} {}
-    update-limit -DSQLITE_ENABLE_UPDATE_DELETE_LIMIT {}
-    memsys5      -DSQLITE_ENABLE_MEMSYS5 {}
-    memsys3      {} {
-      if {[opt-bool memsys5]} {
-        proj-warn "not enabling memsys3 because memsys5 is enabled."
-        expr 0
-      } else {
-        sqlite-add-feature-flag -DSQLITE_ENABLE_MEMSYS3
-      }
-    }
-    bytecode-vtab   -DSQLITE_ENABLE_BYTECODE_VTAB {}
-    scanstatus      {-DSQLITE_ENABLE_STMT_SCANSTATUS -DSQLITE_ENABLE_BYTECODE_VTAB} {}
-    column-metadata -DSQLITE_ENABLE_COLUMN_METADATA {}
-    dbpage          -DSQLITE_ENABLE_DBPAGE_VTAB {}
-    dbstat          -DSQLITE_ENABLE_DBSTAT_VTAB {}
-    carray          -DSQLITE_ENABLE_CARRAY {}
-  }] {
-    if {$boolFlag ni $::autosetup(options)} {
-      # Skip flags which are in the canonical build but not
-      # the autoconf bundle.
-      continue
-    }
-    proj-if-opt-truthy $boolFlag {
-      sqlite-add-feature-flag $featureFlag
-      if {0 != [eval $ifSetEvalThis] && "all" ne $boolFlag} {
-        msg-result "  + $boolFlag"
-      }
-    } {
-      if {"all" ne $boolFlag} {
-        msg-result "  - $boolFlag"
-      }
-    }
-  }
-  ########################################################################
-  # Invert the above loop's logic for some SQLITE_OMIT_...  cases. If
-  # config option $boolFlag is false, [sqlite-add-feature-flag
-  # $featureFlag], where $featureFlag is intended to be
-  # -DSQLITE_OMIT_...
-  foreach {boolFlag featureFlag} {
-    json        -DSQLITE_OMIT_JSON
-  } {
-    if {[proj-opt-truthy $boolFlag]} {
-      msg-result "  + $boolFlag"
-    } else {
-      sqlite-add-feature-flag $featureFlag
-      msg-result "  - $boolFlag"
-    }
-  }
-}
-
-#########################################################################
-# Remove duplicates from the final feature flag sets and show them to
-# the user.
-proc sqlite-finalize-feature-flags {} {
-  set oFF [get-define OPT_FEATURE_FLAGS]
-  if {"" ne $oFF} {
-    define OPT_FEATURE_FLAGS [lsort -unique $oFF]
-    msg-result "Library feature flags: [get-define OPT_FEATURE_FLAGS]"
-  }
-  set oFF [get-define OPT_SHELL]
-  if {"" ne $oFF} {
-    define OPT_SHELL [lsort -unique $oFF]
-    msg-result "Shell options: [get-define OPT_SHELL]"
-  }
-  if {"" ne [set extraSrc [get-define AMALGAMATION_EXTRA_SRC ""]]} {
-    proj-assert {"canonical" eq $::sqliteConfig(build-mode)}
-    msg-result "Appending source files to amalgamation: $extraSrc"
-  }
-  if {[lsearch [get-define TARGET_DEBUG ""] -DSQLITE_DEBUG=1] > -1} {
-    msg-result "Note: this is a debug build, so performance will suffer."
-  }
-}
-
-########################################################################
-# Checks for the --debug flag and [define]s TARGET_DEBUG based on
-# that.  TARGET_DEBUG is unused in the autoconf build but that is
-# arguably a bug.
-proc sqlite-handle-debug {} {
-  msg-checking "SQLITE_DEBUG build? "
-  proj-if-opt-truthy debug {
-    define TARGET_DEBUG {-g -DSQLITE_DEBUG=1 -O0 -Wall}
-    sqlite-add-feature-flag -DSQLITE_ENABLE_SELECTTRACE -DSQLITE_ENABLE_WHERETRACE
-    proj-opt-set memsys5
-    msg-result yes
-  } {
-    define TARGET_DEBUG {-DNDEBUG}
-    msg-result no
-  }
-}
-
-########################################################################
-# "soname" for libsqlite3.so. See discussion at:
-# https://sqlite.org/src/forumpost/5a3b44f510df8ded
-proc sqlite-handle-soname {} {
-  define LDFLAGS_LIBSQLITE3_SONAME ""
-  if {[proj-opt-was-provided soname]} {
-    set soname [join [opt-val soname] ""]
-  } else {
-    # Enabling soname breaks linking for the --dynlink-tools feature,
-    # and this project has no direct use for soname, so default to
-    # none. Package maintainers, on the other hand, like to have an
-    # soname.
-    set soname none
-  }
-  switch -exact -- $soname {
-    none - "" { return 0 }
-    legacy    { set soname libsqlite3.so.0 }
-    default {
-      if {[string match libsqlite3.* $soname]} {
-        # use it as-is
-      } else {
-        # Assume it's a suffix
-        set soname "libsqlite3.so.${soname}"
-      }
-    }
-  }
-  proc-debug "soname=$soname"
-  if {[proj-check-soname $soname]} {
-    define LDFLAGS_LIBSQLITE3_SONAME [get-define LDFLAGS_SONAME_PREFIX]$soname
-    msg-result "Setting SONAME using: [get-define LDFLAGS_LIBSQLITE3_SONAME]"
-  } elseif {[proj-opt-was-provided soname]} {
-    # --soname was explicitly requested but not available, so fail fatally
-    proj-fatal "This environment does not support SONAME."
-  } else {
-    # --soname was not explicitly requested but not available, so just warn
-    msg-result "This environment does not support SONAME."
-  }
-}
-
-########################################################################
-# If --enable-threadsafe is set, this adds -DSQLITE_THREADSAFE=1 to
-# OPT_FEATURE_FLAGS and sets LDFLAGS_PTHREAD to the linker flags
-# needed for linking pthread (possibly an empty string). If
-# --enable-threadsafe is not set, adds -DSQLITE_THREADSAFE=0 to
-# OPT_FEATURE_FLAGS and sets LDFLAGS_PTHREAD to an empty string.
-proc sqlite-handle-threadsafe {} {
-  msg-checking "Support threadsafe operation? "
-  define LDFLAGS_PTHREAD ""
-  set enable 0
-  proj-if-opt-truthy threadsafe {
-    msg-result "Checking for libs..."
-    if {[proj-check-function-in-lib pthread_create pthread]
-        && [proj-check-function-in-lib pthread_mutexattr_init pthread]} {
-      set enable 1
-      define LDFLAGS_PTHREAD [get-define lib_pthread_create]
-      undefine lib_pthread_create
-      undefine lib_pthread_mutexattr_init
-    } elseif {[proj-opt-was-provided threadsafe]} {
-      user-error "Missing required pthread libraries. Use --disable-threadsafe to disable this check."
-    } else {
-      msg-result "pthread support not detected"
-    }
-    # Recall that LDFLAGS_PTHREAD might be empty even if pthreads if
-    # found because it's in -lc on some platforms.
-  } {
-    msg-result "Disabled using --disable-threadsafe"
-  }
-  sqlite-add-feature-flag -DSQLITE_THREADSAFE=${enable}
-  return $enable
-}
-
-########################################################################
-# Handles the --with-tempstore flag.
-#
-# The test fixture likes to set SQLITE_TEMP_STORE on its own, so do
-# not set that feature flag unless it was explicitly provided to the
-# configure script.
-proc sqlite-handle-tempstore {} {
-  if {[proj-opt-was-provided with-tempstore]} {
-    set ts [opt-val with-tempstore no]
-    set tsn 1
-    msg-checking "Use an in-RAM database for temporary tables? "
-    switch -exact -- $ts {
-      never  { set tsn 0 }
-      no     { set tsn 1 }
-      yes    { set tsn 2 }
-      always { set tsn 3 }
-      default {
-        user-error "Invalid --with-tempstore value '$ts'. Use one of: never, no, yes, always"
-      }
-    }
-    msg-result $ts
-    sqlite-add-feature-flag -DSQLITE_TEMP_STORE=$tsn
-  }
-}
-
-########################################################################
-# Check for the Emscripten SDK for building the web-based wasm
-# components.  The core lib and tools do not require this but ext/wasm
-# does. Most of the work is done via [proj-check-emsdk], then this
-# function adds the following defines:
-#
-# - EMCC_WRAPPER = "" or top-srcdir/tool/emcc.sh
-# - BIN_WASM_OPT = "" or path to wasm-opt
-# - BIN_WASM_STRIP = "" or path to wasm-strip
-#
-# Noting that:
-#
-# 1) Not finding the SDK is not fatal at this level, nor is failure to
-#    find one of the related binaries.
-#
-# 2) wasm-strip is part of the wabt package:
-#
-#   https://github.com/WebAssembly/wabt
-#
-# and this project requires it for production-mode builds but not dev
-# builds.
-#
-proc sqlite-handle-emsdk {} {
-  define EMCC_WRAPPER ""
-  define BIN_WASM_STRIP ""
-  define BIN_WASM_OPT ""
-  set srcdir $::autosetup(srcdir)
-  if {$srcdir ne $::autosetup(builddir)} {
-    # The EMSDK pieces require writing to the original source tree
-    # even when doing an out-of-tree build. The ext/wasm pieces do not
-    # support an out-of-tree build so we treat that case as if EMSDK
-    # were not found.
-    msg-result "Out-of tree build: not checking for EMSDK."
-    return
-  }
-  set emccSh $srcdir/tool/emcc.sh
-  set extWasmConfig $srcdir/ext/wasm/config.make
-  if {![get-define HAVE_WASI_SDK] && [proj-check-emsdk]} {
-    define EMCC_WRAPPER $emccSh
-    set emsdkHome [get-define EMSDK_HOME ""]
-    proj-assert {"" ne $emsdkHome}
-    #define EMCC_WRAPPER ""; # just for testing
-    proj-bin-define wasm-strip
-    proj-bin-define bash; # ext/wasm/GNUmakefile requires bash
-    if {[file-isexec $emsdkHome/upstream/bin/wasm-opt]} {
-      define BIN_WASM_OPT $emsdkHome/upstream/bin/wasm-opt
-    } else {
-      # Maybe there's a copy in the path?
-      proj-bin-define wasm-opt BIN_WASM_OPT
-    }
-    proj-dot-ins-append $emccSh.in $emccSh {
-      catch {exec chmod u+x $dotInsOut}
-    }
-    proj-dot-ins-append $extWasmConfig.in $extWasmConfig
-  } else {
-    define EMCC_WRAPPER ""
-    file delete -force -- $emccSh $extWasmConfig
-  }
-}
-
-########################################################################
-# Internal helper for [sqlite-check-line-editing]. Returns a list of
-# potential locations under which readline.h might be found.
-#
-# On some environments this function may perform extra work to help
-# sqlite-check-line-editing figure out how to find libreadline and
-# friends. It will communicate those results via means other than the
-# result value, e.g. by modifying configure --flags.
-proc sqlite-get-readline-dir-list {} {
-  # Historical note: the dirs list, except for the inclusion of
-  # $prefix and some platform-specific dirs, originates from the
-  # legacy configure script.
-  set dirs [list [get-define prefix]]
-  switch -glob -- [get-define host] {
-    *-linux-android {
-      # Possibly termux
-      lappend dirs /data/data/com.termux/files/usr
-    }
-    *-mingw32 {
-      lappend dirs /mingw32 /mingw
-    }
-    *-mingw64 {
-      lappend dirs /mingw64 /mingw
-    }
-    *-haiku {
-      lappend dirs /boot/system/develop/headers
-      if {[opt-val with-readline-ldflags] in {auto ""}} {
-        # If the user did not supply their own --with-readline-ldflags
-        # value, hijack that flag to inject options which are known to
-        # work on Haiku OS installations.
-        if {"" ne [glob -nocomplain /boot/system/lib/libreadline*]} {
-          proj-opt-set with-readline-ldflags {-L/boot/system/lib -lreadline}
-        }
-      }
-    }
-  }
-  lappend dirs /usr /usr/local /usr/local/readline /usr/contrib
-  set rv {}
-  foreach d $dirs {
-    if {[file isdir $d]} {lappend rv $d}
-  }
-  #proc-debug "dirs=$rv"
-  return $rv
-}
-
-########################################################################
-# sqlite-check-line-editing jumps through proverbial hoops to try to
-# find a working line-editing library, setting:
-#
-#   - HAVE_READLINE to 0 or 1
-#   - HAVE_LINENOISE to 0, 1, or 2
-#   - HAVE_EDITLINE to 0 or 1
-#
-# Only one of ^^^ those will be set to non-0.
-#
-#   - LDFLAGS_READLINE = linker flags or empty string
-#
-#   - CFLAGS_READLINE = compilation flags for clients or empty string.
-#
-# Note that LDFLAGS_READLINE and CFLAGS_READLINE may refer to
-# linenoise or editline, not necessarily libreadline.  In some cases
-# it will set HAVE_READLINE=1 when it's really using editline, for
-# reasons described in this function's comments.
-#
-# Returns a string describing which line-editing approach to use, or
-# "none" if no option is available.
-#
-# Order of checks:
-#
-#  1) --with-linenoise trumps all others and skips all of the
-#     complexities involved with the remaining options.
-#
-#  2) --editline trumps --readline
-#
-#  3) --disable-readline trumps --readline
-#
-#  4) Default to automatic search for optional readline
-#
-#  5) Try to find readline or editline. If it's not found AND the
-#     corresponding --FEATURE flag was explicitly given then fail
-#     fatally, else fail non-fatally.
-proc sqlite-check-line-editing {} {
-  msg-result "Checking for line-editing capability..."
-  define HAVE_READLINE 0
-  define HAVE_LINENOISE 0
-  define HAVE_EDITLINE 0
-  define LDFLAGS_READLINE ""
-  define CFLAGS_READLINE ""
-  set failIfNotFound 0 ; # Gets set to 1 for explicit --FEATURE requests
-                         # so that we know whether to fail fatally or not
-                         # if the library is not found.
-  set libsForReadline {readline edit} ; # -l<LIB> names to check for readline().
-                                        # The libedit check changes this.
-  set editLibName "readline"     ; # "readline" or "editline"
-  set editLibDef "HAVE_READLINE" ; # "HAVE_READLINE" or "HAVE_EDITLINE"
-  set dirLn [opt-val with-linenoise]
-
-  # If none of --with-linenoise, --enable-readline, or --enable-editline
-  # are provided, but there exists a directory "linenoise" at $HOME or
-  # a sibling of the build or source directory, then try to use that linenoise
-  # direcctory.
-  #
-  if {"" eq $dirLn
-   && ![proj-opt-was-provided readline]
-   && ![proj-opt-was-provided editline]
-  } {
-    set dirlist ../linenoise
-    catch {lappend dirlist [file-normalize $::autosetup(srcdir)/../linenoise]}
-    catch {lappend dirlist $::env(HOME)/linenoise}
-    foreach d $dirlist {
-      if {[file exists $d/linenoise.c] && [file exists $d/linenoise.h]} {
-        set dirLn $d
-        break
-      }
-    }
-  }
-
-  if {"" ne $dirLn} {
-    # Use linenoise from a copy of its sources (not a library)...
-    if {![file isdir $dirLn]} {
-      proj-fatal "--with-linenoise value is not a directory"
-    }
-    set lnH $dirLn/linenoise.h
-    if {![file exists $lnH] } {
-      proj-fatal "Cannot find linenoise.h in $dirLn"
-    }
-    set lnC ""
-    set lnCOpts {linenoise-ship.c linenoise.c}
-    foreach f $lnCOpts {
-      if {[file exists $dirLn/$f]} {
-        set lnC $dirLn/$f
-        break
-      }
-    }
-    if {"" eq $lnC} {
-      proj-fatal "Cannot find any of $lnCOpts in $dirLn"
-    }
-    set flavor ""
-    set lnVal [proj-which-linenoise $lnH]
-    switch -- $lnVal {
-      1 { set flavor "antirez" }
-      2 { set flavor "msteveb" }
-      default {
-        proj-fatal "Cannot determine the flavor of linenoise from $lnH"
-      }
-    }
-    define CFLAGS_READLINE "-I$dirLn $lnC"
-    define HAVE_LINENOISE $lnVal
-    sqlite-add-shell-opt -DHAVE_LINENOISE=$lnVal
-    if {$::sqliteConfig(use-jim-for-codegen) && 2 == $lnVal} {
-      define-append CFLAGS_JIMSH -DUSE_LINENOISE [get-define CFLAGS_READLINE]
-      user-notice "Adding linenoise support to jimsh."
-    } else {
-      msg-result "Using linenoise at [file-normalize $dirLn]"
-    }
-    return "linenoise ($flavor)"
-  } elseif {[opt-bool editline]} {
-    # libedit mimics libreadline and on some systems does not have its
-    # own header installed (instead, that of libreadline is used).
-    #
-    # shell.c historically expects HAVE_EDITLINE to be set for
-    # libedit, but it then expects to see <editline/readline.h>, which
-    # some system's don't actually have despite having libedit.  If we
-    # end up finding <editline/readline.h> below, we will use
-    # -DHAVE_EDITLINE=1, else we will use -DHAVE_READLINE=1. In either
-    # case, we will link against libedit.
-    set failIfNotFound 1
-    set libsForReadline {edit}
-    set editLibName editline
-  } elseif {![opt-bool readline]} {
-    msg-result "Readline support explicitly disabled with --disable-readline"
-    return "none"
-  } elseif {[proj-opt-was-provided readline]} {
-    # If an explicit --[enable-]readline was used, fail if it's not
-    # found, else treat the feature as optional.
-    set failIfNotFound 1
-  }
-
-  # Transform with-readline-header=X to with-readline-cflags=-I...
-  set v [opt-val with-readline-header]
-  proj-opt-set with-readline-header ""
-  if {"" ne $v} {
-    if {"auto" eq $v} {
-      proj-opt-set with-readline-cflags auto
-    } else {
-      set v [file dirname $v]
-      if {[string match */readline $v]} {
-        # Special case: if the path includes .../readline/readline.h,
-        # set the -I to one dir up from that because our sources
-        # #include <readline/readline.h> or <editline/readline.h>.
-        set v [file dirname $v]
-      }
-      proj-opt-set with-readline-cflags "-I$v"
-    }
-  }
-
-  # Look for readline.h
-  set rlInc [opt-val with-readline-cflags auto]
-  if {"auto" eq $rlInc} {
-    set rlInc ""
-    if {$::sqliteConfig(is-cross-compiling)} {
-      # ^^^ this check is derived from the legacy configure script.
-      proj-warn "Skipping check for readline.h because we're cross-compiling."
-    } else {
-      set dirs [sqlite-get-readline-dir-list]
-      set subdirs [list \
-                     include/$editLibName \
-                     readline]
-      if {"editline" eq $editLibName} {
-        lappend subdirs include/readline
-        # ^^^ editline, on some systems, does not have its own header,
-        # and uses libreadline's header.
-      }
-      lappend subdirs include
-      set rlInc [proj-search-for-header-dir readline.h \
-                   -dirs $dirs -subdirs $subdirs]
-      #proc-debug "rlInc=$rlInc"
-      if {"" ne $rlInc} {
-        if {[string match */readline $rlInc]} {
-          set rlInc [file dirname $rlInc]; # CLI shell: #include <readline/readline.h>
-        } elseif {[string match */editline $rlInc]} {
-          set editLibDef HAVE_EDITLINE
-          set rlInc [file dirname $rlInc]; # CLI shell: #include <editline/readline.h>
-        }
-        set rlInc "-I${rlInc}"
-      }
-    }
-  } elseif {"" ne $rlInc && ![string match *-I* $rlInc]} {
-    proj-fatal "Argument to --with-readline-cflags is intended to be CFLAGS and contain -I..."
-  }
-
-  # If readline.h was found/specified, look for lib(readline|edit)...
-  #
-  # This is not quite straightforward because both libreadline and
-  # libedit typically require some other library which (according to
-  # legacy autotools-generated tests) provides tgetent(3). On some
-  # systems that's built into libreadline/edit, on some (most?) its in
-  # lib[n]curses, and on some it's in libtermcap.
-  set rlLib ""
-  if {"" ne $rlInc} {
-    set rlLib [opt-val with-readline-ldflags]
-    #proc-debug "rlLib=$rlLib"
-    if {$rlLib in {auto ""}} {
-      set rlLib ""  ; # make sure it's not "auto", as we may append to it below
-      set libTerm ""; # lib with tgetent(3)
-      if {[proj-check-function-in-lib tgetent [list $editLibName ncurses curses termcap]]} {
-        # ^^^ that libs list comes from the legacy configure script ^^^
-        set libTerm [get-define lib_tgetent]
-        undefine lib_tgetent
-      }
-      if {$editLibName eq $libTerm} {
-        # tgetent(3) was found in the editing library
-        set rlLib $libTerm
-      } elseif {[proj-check-function-in-lib readline $libsForReadline $libTerm]} {
-        # tgetent(3) was found in an external lib
-        set rlLib [get-define lib_readline]
-        lappend rlLib $libTerm
-        undefine lib_readline
-      }
-    }
-  }
-
-  # If we found a library, configure the build to use it...
-  if {"" ne $rlLib} {
-    if {"editline" eq $editLibName && "HAVE_READLINE" eq $editLibDef} {
-      # Alert the user that, despite outward appearances, we won't be
-      # linking to the GPL'd libreadline. Presumably that distinction is
-      # significant for those using --editline.
-      proj-indented-notice {
-        NOTE: the local libedit uses <readline/readline.h> so we
-        will compile with -DHAVE_READLINE=1 but will link with
-        libedit.
-      }
-    }
-    set rlLib [join $rlLib]
-    set rlInc [join $rlInc]
-    define LDFLAGS_READLINE $rlLib
-    define CFLAGS_READLINE $rlInc
-    proj-assert {$editLibDef in {HAVE_READLINE HAVE_EDITLINE}}
-    proj-assert {$editLibName in {readline editline}}
-    sqlite-add-shell-opt -D${editLibDef}=1
-    msg-result "Using $editLibName flags: $rlInc $rlLib"
-    # Check whether rl_completion_matches() has a signature we can use
-    # and disable that sub-feature if it doesn't.
-    if {![cctest -cflags "$rlInc -D${editLibDef}" -libs $rlLib -nooutput 1 \
-            -source {
-             #include <stdio.h>
-             #ifdef HAVE_EDITLINE
-             #include <editline/readline.h>
-             #else
-             #include <readline/readline.h>
-             #endif
-             static char * rcg(const char *z, int i){(void)z; (void)i; return 0;}
-             int main(void) {
-               char ** x = rl_completion_matches("one", rcg);
-               (void)x;
-               return 0;
-             }
-           }]} {
-      proj-warn "readline-style completion disabled due to rl_completion_matches() signature mismatch"
-      sqlite-add-shell-opt -DSQLITE_OMIT_READLINE_COMPLETION
-    }
-    return $editLibName
-  }
-
-  if {$failIfNotFound} {
-    proj-fatal "Explicit --$editLibName failed to find a matching library."
-  }
-  return "none"
-}; # sqlite-check-line-editing
-
-########################################################################
-# Runs sqlite-check-line-editing and adds a message around it. In the
-# canonical build this must not be called before
-# sqlite-determine-codegen-tcl for reasons now lost to history (and
-# might not still be applicable).
-proc sqlite-handle-line-editing {} {
-  msg-result "Line-editing support for the sqlite3 shell: [sqlite-check-line-editing]"
-}
-
-
-########################################################################
-# ICU - International Components for Unicode
-#
-# Handles these flags:
-#
-#  --with-icu-ldflags=LDFLAGS
-#  --with-icu-cflags=CFLAGS
-#  --with-icu-config[=auto | pkg-config | /path/to/icu-config]
-#  --enable-icu-collations
-#
-# --with-icu-config values:
-#
-#   - auto: use the first one of (pkg-config, icu-config) found on the
-#     system.
-#   - pkg-config: use only pkg-config to determine flags
-#   - /path/to/icu-config: use that to determine flags
-#
-# If --with-icu-config is used and neither pkg-config nor icu-config
-# are found, fail fatally.
-#
-# If both --with-icu-ldflags and --with-icu-config are provided, they
-# are cumulative.  If neither are provided, icu-collations is not
-# honored and a warning is emitted if it is provided.
-#
-# Design note: though we could automatically enable ICU if the
-# icu-config binary or (pkg-config icu-io) are found, we specifically
-# do not. ICU is always an opt-in feature.
-proc sqlite-handle-icu {} {
-  define LDFLAGS_ICU [join [opt-val with-icu-ldflags ""]]
-  define CFLAGS_ICU [join [opt-val with-icu-cflags ""]]
-  if {[proj-opt-was-provided with-icu-config]} {
-    msg-result "Checking for ICU support..."
-    set icuConfigBin [opt-val with-icu-config]
-    set tryIcuConfigBin 1; # set to 0 if we end up using pkg-config
-    if {$icuConfigBin in {auto pkg-config}} {
-      if {[pkg-config-init 0] && [pkg-config icu-io]} {
-        # Maintenance reminder: historical docs say to use both of
-        # (icu-io, icu-uc). icu-uc lacks a required lib and icu-io has
-        # all of them on tested OSes.
-        set tryIcuConfigBin 0
-        define LDFLAGS_ICU [get-define PKG_ICU_IO_LDFLAGS]
-        define-append LDFLAGS_ICU [get-define PKG_ICU_IO_LIBS]
-        define CFLAGS_ICU [get-define PKG_ICU_IO_CFLAGS]
-      } elseif {"pkg-config" eq $icuConfigBin} {
-        proj-fatal "pkg-config cannot find package icu-io"
-      } else {
-        proj-assert {"auto" eq $icuConfigBin}
-      }
-    }
-    if {$tryIcuConfigBin} {
-      if {"auto" eq $icuConfigBin} {
-        set icuConfigBin [proj-first-bin-of \
-                            /usr/local/bin/icu-config \
-                            /usr/bin/icu-config]
-        if {"" eq $icuConfigBin} {
-          proj-indented-notice -error {
-            --with-icu-config=auto cannot find (pkg-config icu-io) or icu-config binary.
-            On Ubuntu-like systems try:
-            --with-icu-ldflags='-licui18n -licuuc -licudata'
-          }
-        }
-      }
-      if {[file-isexec $icuConfigBin]} {
-        set x [exec $icuConfigBin --ldflags]
-        if {"" eq $x} {
-          proj-indented-notice -error \
-            [subst {
-              $icuConfigBin --ldflags returned no data.
-              On Ubuntu-like systems try:
-              --with-icu-ldflags='-licui18n -licuuc -licudata'
-            }]
-        }
-        define-append LDFLAGS_ICU $x
-        set x [exec $icuConfigBin --cppflags]
-        define-append CFLAGS_ICU $x
-      } else {
-        proj-fatal "--with-icu-config=$icuConfigBin does not refer to an executable"
-      }
-    }
-  }
-  set ldflags [define LDFLAGS_ICU [string trim [get-define LDFLAGS_ICU]]]
-  set cflags [define CFLAGS_ICU [string trim [get-define CFLAGS_ICU]]]
-  if {"" ne $ldflags} {
-    sqlite-add-feature-flag -shell -DSQLITE_ENABLE_ICU
-    msg-result "Enabling ICU support with flags: $ldflags $cflags"
-    if {[opt-bool icu-collations]} {
-      msg-result "Enabling ICU collations."
-      sqlite-add-feature-flag -shell -DSQLITE_ENABLE_ICU_COLLATIONS
-      # Recall that shell.c builds with sqlite3.c except in the case
-      # of --disable-static-shell, a combination we do not
-      # specifically attempt to account for.
-    }
-  } elseif {[opt-bool icu-collations]} {
-    proj-warn "ignoring --enable-icu-collations because neither --with-icu-ldflags nor --with-icu-config provided any linker flags"
-  } else {
-    msg-result "ICU support is disabled."
-  }
-}; # sqlite-handle-icu
-
-
-########################################################################
-# Handles the --enable-load-extension flag. Returns 1 if the support
-# is enabled, else 0. If support for that feature is not found, a
-# fatal error is triggered if --enable-load-extension is explicitly
-# provided, else a loud warning is instead emitted. If
-# --disable-load-extension is used, no check is performed.
-#
-# Makes the following environment changes:
-#
-# - defines LDFLAGS_DLOPEN to any linker flags needed for this
-#   feature.  It may legally be empty on (A) some systems where
-#   dlopen() is in libc and (B) certain Unix-esque Windows
-#   environments which identify as Windows for SQLite's purposes so
-#   use LoadLibrary().
-#
-# - If the feature is not available, adds
-#   -DSQLITE_OMIT_LOAD_EXTENSION=1 to the feature flags list.
-proc sqlite-handle-load-extension {} {
-  define LDFLAGS_DLOPEN ""
-  set found 0
-  set suffix ""
-  proj-if-opt-truthy load-extension {
-    switch -glob -- [get-define host] {
-      *-*-mingw* - *windows* {
-        incr found
-        set suffix "Using LoadLibrary()"
-      }
-      default {
-        set found [proj-check-function-in-lib dlopen dl]
-        if {$found} {
-          set suffix [define LDFLAGS_DLOPEN [get-define lib_dlopen]]
-          undefine lib_dlopen
-        } else {
-          if {[proj-opt-was-provided load-extension]} {
-            # Explicit --enable-load-extension: fail if not found
-            proj-indented-notice -error {
-              --enable-load-extension was provided but dlopen()
-              not found. Use --disable-load-extension to bypass this
-              check.
-            }
-          } else {
-            # It was implicitly enabled: warn if not found
-            proj-indented-notice {
-              WARNING: dlopen() not found, so loadable module support will
-              be disabled. Use --disable-load-extension to bypass this
-              check.
-            }
-          }
-        }
-      }
-    }
-  }
-  if {$found} {
-    msg-result "Loadable extension support enabled. $suffix"
-  } else {
-    msg-result "Disabling loadable extension support. Use --enable-load-extension to enable them."
-    sqlite-add-feature-flag -DSQLITE_OMIT_LOAD_EXTENSION=1
-  }
-  return $found
-}
-
-########################################################################
-# Handles the --enable-math flag.
-proc sqlite-handle-math {} {
-  proj-if-opt-truthy math {
-    if {![proj-check-function-in-lib ceil m]} {
-      user-error "Cannot find libm functions. Use --disable-math to bypass this."
-    }
-    define LDFLAGS_MATH [get-define lib_ceil]
-    undefine lib_ceil
-    sqlite-add-feature-flag -DSQLITE_ENABLE_MATH_FUNCTIONS -DSQLITE_ENABLE_PERCENTILE
-    msg-result "Enabling math SQL functions"
-  } {
-    define LDFLAGS_MATH ""
-    msg-result "Disabling math SQL functions"
-  }
-}
-
-########################################################################
-# If this OS looks like a Mac, checks for the Mac-specific
-# -current_version and -compatibility_version linker flags. Defines
-# LDFLAGS_MAC_CVERSION to an empty string and returns 0 if they're not
-# supported, else defines that to the linker flags and returns 1.
-#
-# We don't check this on non-Macs because this whole thing is a
-# libtool compatibility kludge to account for a version stamp which
-# libtool applied only on Mac platforms.
-#
-# Based on https://sqlite.org/forum/forumpost/9dfd5b8fd525a5d7.
-proc sqlite-handle-mac-cversion {} {
-  define LDFLAGS_MAC_CVERSION ""
-  set rc 0
-  if {[proj-looks-like-mac]} {
-    cc-with {-link 1} {
-      # These version numbers are historical libtool-defined values, not
-      # library-defined ones
-      if {[cc-check-flags "-Wl,-current_version,9.6.0"]
-          && [cc-check-flags "-Wl,-compatibility_version,9.0.0"]} {
-        define LDFLAGS_MAC_CVERSION "-Wl,-compatibility_version,9.0.0 -Wl,-current_version,9.6.0"
-        set rc 1
-      } elseif {[cc-check-flags "-compatibility_version 9.0.0"]
-                && [cc-check-flags "-current_version 9.6.0"]} {
-        define LDFLAGS_MAC_CVERSION "-compatibility_version 9.0.0 -current_version 9.6.0"
-        set rc 1
-      }
-    }
-  }
-  return $rc
-}
-
-########################################################################
-# If this is a Mac platform, check for support for
-# -Wl,-install_name,...  and, if it's available, define
-# LDFLAGS_MAC_INSTALL_NAME to a variant of that string which is
-# intended to expand at make-time, else set LDFLAGS_MAC_INSTALL_NAME
-# to an empty string.
-#
-# https://sqlite.org/forum/forumpost/5651662b8875ec0a
-proc sqlite-handle-mac-install-name {} {
-  define LDFLAGS_MAC_INSTALL_NAME ""; # {-Wl,-install_name,"$(install-dir.lib)/$(libsqlite3.DLL)"}
-  set rc 0
-  if {[proj-looks-like-mac]} {
-    cc-with {-link 1} {
-      if {[cc-check-flags "-Wl,-install_name,/usr/local/lib/libsqlite3.dylib"]} {
-        define LDFLAGS_MAC_INSTALL_NAME {-Wl,-install_name,"$(install-dir.lib)/$(libsqlite3.DLL)"}
-        set rc 1
-      }
-    }
-  }
-  return $rc
-}
-
-#
-# Checks specific to HP-UX.
-#
-proc sqlite-handle-hpux {} {
-  switch -glob -- [get-define host] {
-    *hpux* {
-      if {[cc-check-flags "-Ae"]} {
-        define-append CFLAGS -Ae
-      }
-    }
-  }
-}
-
-########################################################################
-# Handles the --dll-basename configure flag. [define]'s
-# SQLITE_DLL_BASENAME to the DLL's preferred base name (minus
-# extension). If --dll-basename is not provided (or programmatically
-# set - see [sqlite-handle-env-quirks]) then this is always
-# "libsqlite3", otherwise it may use a different value based on the
-# value of [get-define host].
-proc sqlite-handle-dll-basename {} {
-  if {[proj-opt-was-provided dll-basename]} {
-    set dn [join [opt-val dll-basename] ""]
-    if {$dn in {none default}} { set dn libsqlite3 }
-  } else {
-    set dn libsqlite3
-  }
-  if {$dn in {auto ""}} {
-    switch -glob -- [get-define host] {
-      *-*-cygwin  { set dn cygsqlite3-0 }
-      *-*-ming*   { set dn libsqlite3-0 }
-      *-*-msys    { set dn msys-sqlite3-0 }
-      default     { set dn libsqlite3 }
-    }
-  }
-  define SQLITE_DLL_BASENAME $dn
-}
-
-########################################################################
-# [define]s LDFLAGS_OUT_IMPLIB to either an empty string or to a
-# -Wl,... flag for the platform-specific --out-implib flag, which is
-# used for building an "import library .dll.a" file on some platforms
-# (e.g. msys2, mingw). SQLITE_OUT_IMPLIB is defined to the name of the
-# import lib or an empty string. Returns 1 if supported, else 0.
-#
-# The name of the import library is [define]d in SQLITE_OUT_IMPLIB.
-#
-# If the configure flag --out-implib is not used (or programmatically
-# set) then this simply sets the above-listed defines to empty strings
-# (but see [sqlite-handle-env-quirks]).  If that flag is used but the
-# capability is not available, a fatal error is triggered.
-#
-# This feature is specifically opt-in because it's supported on far
-# more platforms than actually need it and enabling it causes creation
-# of libsqlite3.so.a files which are unnecessary in most environments.
-#
-# Added in response to: https://sqlite.org/forum/forumpost/0c7fc097b2
-#
-# Platform notes:
-#
-# - cygwin sqlite packages historically install no .dll.a file.
-#
-# - msys2 and mingw sqlite packages historically install
-#   /usr/lib/libsqlite3.dll.a despite the DLL being in
-#   /usr/bin.
-proc sqlite-handle-out-implib {} {
-  define LDFLAGS_OUT_IMPLIB ""
-  define SQLITE_OUT_IMPLIB ""
-  set rc 0
-  if {[proj-opt-was-provided out-implib]} {
-    set olBaseName [join [opt-val out-implib] ""]
-    if {$olBaseName in {auto ""}} {
-      set olBaseName "libsqlite3" ;# [get-define SQLITE_DLL_BASENAME]
-      # Based on discussions with mingw/msys users, the import lib
-      # should always be called libsqlite3.dll.a even on platforms
-      # which rename libsqlite3.dll to something else.
-    }
-    if {$olBaseName ne "none"} {
-      cc-with {-link 1} {
-        set dll "${olBaseName}[get-define TARGET_DLLEXT]"
-        set flags [proj-cc-check-Wl-flag --out-implib ${dll}.a]
-        if {"" ne $flags} {
-          define LDFLAGS_OUT_IMPLIB $flags
-          define SQLITE_OUT_IMPLIB ${dll}.a
-          set rc 1
-        }
-      }
-      if {!$rc} {
-        user-error "--out-implib is not supported on this platform"
-      }
-    }
-  }
-  return $rc
-}
-
-########################################################################
-# If the given platform identifier (defaulting to [get-define host])
-# appears to be one of the Unix-on-Windows environments, returns a
-# brief symbolic name for that environment, else returns an empty
-# string.
-#
-# It does not distinguish between msys and msys2, returning msys for
-# both. The build does not, as of this writing, specifically support
-# msys v1. Similarly, this function returns "mingw" for both "mingw32"
-# and "mingw64".
-proc sqlite-env-is-unix-on-windows {{envTuple ""}} {
-  if {"" eq $envTuple} {
-    set envTuple [get-define host]
-  }
-  set name ""
-  switch -glob -- $envTuple {
-    *-*-cygwin { set name cygwin }
-    *-*-ming*  { set name mingw }
-    *-*-msys   { set name msys }
-  }
-  return $name
-}
-
-########################################################################
-# Performs various tweaks to the build which are only relevant on
-# certain platforms, e.g. Mac and "Unix on Windows" platforms (msys2,
-# cygwin, ...).
-#
-# 1) DLL installation:
-#
-# [define]s SQLITE_DLL_INSTALL_RULES to a symbolic name suffix for a
-# set of "make install" rules to use for installation of the DLL
-# deliverable. The makefile is tasked with providing rules named
-# install-dll-NAME which runs the installation for that set, as well
-# as providing a rule named install-dll which resolves to
-# install-dll-NAME (perhaps indirectly, depending on whether the DLL
-# is (de)activated).
-#
-# The default value is "unix-generic".
-#
-# 2) --out-implib:
-#
-# On platforms where an "import library" is conventionally used but
-# --out-implib was not explicitly used, automatically add that flag.
-# This conventionally applies only to the "Unix on Windows"
-# environments like msys and cygwin.
-#
-# 3) --dll-basename:
-#
-# On the same platforms addressed by --out-implib, if --dll-basename
-# is not explicitly specified, --dll-basename=auto is implied.
-proc sqlite-handle-env-quirks {} {
-  set instName unix-generic; # name of installation rules set
-  set autoDll 0; # true if --out-implib/--dll-basename should be implied
-  set host [get-define host]
-  switch -glob -- $host {
-    *apple* -
-    *darwin*    { set instName darwin }
-    default {
-      set x [sqlite-env-is-unix-on-windows $host]
-      if {"" ne $x} {
-        set instName $x
-        set autoDll 1
-      }
-    }
-  }
-  define SQLITE_DLL_INSTALL_RULES $instName
-  if {$autoDll} {
-    if {![proj-opt-was-provided out-implib]} {
-      # Imply --out-implib=auto
-      proj-indented-notice [subst -nocommands -nobackslashes {
-        NOTICE: auto-enabling --out-implib for environment [$host].
-        Use --out-implib=none to disable this special case
-        or --out-implib=auto to squelch this notice.
-      }]
-      proj-opt-set out-implib auto
-    }
-    if {![proj-opt-was-provided dll-basename]} {
-      # Imply --dll-basename=auto
-      proj-indented-notice [subst -nocommands -nobackslashes {
-        NOTICE: auto-enabling --dll-basename for environment [$host].
-        Use --dll-basename=default to disable this special case
-        or --dll-basename=auto to squelch this notice.
-      }]
-      proj-opt-set dll-basename auto
-    }
-  }
-  sqlite-handle-dll-basename
-  sqlite-handle-out-implib
-  sqlite-handle-mac-cversion
-  sqlite-handle-mac-install-name
-  if {[llength [info proc sqlite-custom-handle-flags]] > 0} {
-    # sqlite-custom-handle-flags is assumed to be imported via a
-    # client-specific import: autosetup/sqlite-custom.tcl.
-    sqlite-custom-handle-flags
-  }
-}
-
-########################################################################
-# Perform some late-stage work and generate the configure-process
-# output file(s).
-proc sqlite-process-dot-in-files {} {
-  ########################################################################
-  # "Re-export" the autoconf-conventional --XYZdir flags into something
-  # which is more easily overridable from a make invocation. See the docs
-  # for [proj-remap-autoconf-dir-vars] for the explanation of why.
-  #
-  # We do this late in the config process, immediately before we export
-  # the Makefile and other generated files, so that configure tests
-  # which make make use of the autotools-conventional flags
-  # (e.g. [proj-check-rpath]) may do so before we "mangle" them here.
-  proj-remap-autoconf-dir-vars
-
-  proj-dot-ins-process -validate
-  make-config-header sqlite_cfg.h \
-    -bare {SIZEOF_* HAVE_DECL_*} \
-    -none {HAVE_CFLAG_* LDFLAGS_* SH_* SQLITE_AUTORECONFIG
-      TARGET_* USE_GCOV TCL_*} \
-    -auto {HAVE_* PACKAGE_*} \
-    -none *
-  proj-touch sqlite_cfg.h ; # help avoid frequent unnecessary @SQLITE_AUTORECONFIG@
-}
-
-########################################################################
-# Handle --with-wasi-sdk[=DIR]
-#
-# This must be run relatively early on because it may change the
-# toolchain and disable a number of config options. However, in the
-# canonical build this must come after [sqlite-check-common-bins].
-proc sqlite-handle-wasi-sdk {} {
-  set wasiSdkDir [opt-val with-wasi-sdk] ; # ??? [lindex [opt-val with-wasi-sdk] end]
-  define HAVE_WASI_SDK 0
-  if {$wasiSdkDir eq ""} {
-    return 0
-  } elseif {$::sqliteConfig(is-cross-compiling)} {
-    proj-fatal "Cannot combine --with-wasi-sdk with cross-compilation"
-  }
-  msg-result "Checking WASI SDK directory \[$wasiSdkDir]... "
-  proj-affirm-files-exist -v {*}[prefix "$wasiSdkDir/bin/" {clang wasm-ld ar}]
-  define HAVE_WASI_SDK 1
-  define WASI_SDK_DIR $wasiSdkDir
-  # Disable numerous options which we know either can't work or are
-  # not useful in this build...
-  msg-result "Using wasi-sdk clang. Disabling CLI shell and modifying config flags:"
-  # Boolean (--enable-/--disable-) flags which must be switched off:
-  foreach opt {
-    dynlink-tools
-    editline
-    gcov
-    icu-collations
-    load-extension
-    readline
-    shared
-    tcl
-    threadsafe
-  } {
-    if {[proj-opt-exists $opt] && [opt-bool $opt]} {
-      # -^^^^ not all builds define all of these flags
-      msg-result "  --disable-$opt"
-      proj-opt-set $opt 0
-    }
-  }
-  # Non-boolean flags which need to be cleared:
-  foreach opt {
-    with-emsdk
-    with-icu-config
-    with-icu-ldflags
-    with-icu-cflags
-    with-linenoise
-    with-tcl
-  } {
-    if {[proj-opt-was-provided $opt]} {
-      msg-result "  removing --$opt"
-      proj-opt-set $opt ""
-    }
-  }
-  # Remember that we now have a discrepancy between
-  # $::sqliteConfig(is-cross-compiling) and [proj-is-cross-compiling].
-  set ::sqliteConfig(is-cross-compiling) 1
-
-  #
-  # Changing --host and --target have no effect here except to
-  # possibly cause confusion. Autosetup has finished processing them
-  # by this point.
-  #
-  #  host_alias=wasm32-wasi
-  #  target=wasm32-wasi
-  #
-  # Merely changing CC, LD, and AR to the wasi-sdk's is enough to get
-  # sqlite3.o building in WASM format.
-  #
-  define CC "${wasiSdkDir}/bin/clang"
-  define LD "${wasiSdkDir}/bin/wasm-ld"
-  define AR "${wasiSdkDir}/bin/ar"
-  #define STRIP "${wasiSdkDir}/bin/strip"
-  return 1
-}; # sqlite-handle-wasi-sdk
-
-########################################################################
-# TCL...
-#
-# sqlite-check-tcl performs most of the --with-tcl and --with-tclsh
-# handling. Some related bits and pieces are performed before and
-# after that function is called.
-#
-# Important [define]'d vars:
-#
-#  - HAVE_TCL indicates whether we have a tclsh suitable for building
-#    the TCL SQLite extension and, by extension, the testing
-#    infrastructure. This must only be 1 for environments where
-#    tclConfig.sh can be found.
-#
-#  - TCLSH_CMD is the path to the canonical tclsh or "". It never
-#    refers to jimtcl.
-#
-#  - TCL_CONFIG_SH is the path to tclConfig.sh or "".
-#
-#  - TCLLIBDIR is the dir to which libtclsqlite3 gets installed.
-#
-#  - BTCLSH = the path to the tcl interpreter used for in-tree code
-#    generation.  It may be jimtcl or the canonical tclsh but may not
-#    be empty - this tree requires TCL to generated numerous
-#    components.
-#
-# If --tcl or --with-tcl are provided but no TCL is found, this
-# function fails fatally. If they are not explicitly provided then
-# failure to find TCL is not fatal but a loud warning will be emitted.
-#
-proc sqlite-check-tcl {} {
-  define TCLSH_CMD false ; # Significant is that it exits with non-0
-  define HAVE_TCL 0      ; # Will be enabled via --tcl or a successful search
-  define TCLLIBDIR ""    ; # Installation dir for TCL extension lib
-  define TCL_CONFIG_SH ""; # full path to tclConfig.sh
-
-  # Clear out all vars which would harvest from tclConfig.sh so that
-  # the late-config validation of @VARS@ works even if --disable-tcl
-  # is used.
-  proj-tclConfig-sh-to-autosetup ""
-
-  file delete -force ".tclenv.sh"; # ensure no stale state from previous configures.
-  if {![opt-bool tcl]} {
-    proj-indented-notice {
-      NOTE: TCL is disabled via --disable-tcl. This means that none
-      of the TCL-based components will be built, including tests
-      and sqlite3_analyzer.
-    }
-    return
-  }
-  # TODO: document the steps this is taking.
-  set srcdir $::autosetup(srcdir)
-  msg-result "Checking for a suitable tcl... "
-  proj-assert [proj-opt-truthy tcl]
-  set use_tcl 1
-  set with_tclsh [opt-val with-tclsh]
-  set with_tcl [opt-val with-tcl]
-  if {"prefix" eq $with_tcl} {
-    set with_tcl [get-define prefix]
-  }
-  proc-debug "use_tcl ${use_tcl}"
-  proc-debug "with_tclsh=${with_tclsh}"
-  proc-debug "with_tcl=$with_tcl"
-  if {"" eq $with_tclsh && "" eq $with_tcl} {
-    # If neither --with-tclsh nor --with-tcl are provided, try to find
-    # a workable tclsh.
-    set with_tclsh [proj-first-bin-of tclsh9.1 tclsh9.0 tclsh8.6 tclsh]
-    proc-debug "with_tclsh=${with_tclsh}"
-  }
-
-  set doConfigLookup 1 ; # set to 0 to test the tclConfig.sh-not-found cases
-  if {"" ne $with_tclsh} {
-    # --with-tclsh was provided or found above. Validate it and use it
-    # to trump any value passed via --with-tcl=DIR.
-    if {![file-isexec $with_tclsh]} {
-      proj-fatal "TCL shell $with_tclsh is not executable"
-    } else {
-      define TCLSH_CMD $with_tclsh
-      #msg-result "Using tclsh: $with_tclsh"
-    }
-    if {$doConfigLookup &&
-        [catch {exec $with_tclsh $::autosetup(libdir)/find_tclconfig.tcl} result] == 0} {
-      set with_tcl $result
-    }
-    if {"" ne $with_tcl && [file isdir $with_tcl]} {
-      msg-result "$with_tclsh recommends the tclConfig.sh from $with_tcl"
-    } else {
-      proj-warn "$with_tclsh is unable to recommend a tclConfig.sh"
-      set use_tcl 0
-    }
-  }
-  set cfg ""
-  set tclSubdirs {tcl9.1 tcl9.0 tcl8.6 lib}
-  while {$use_tcl} {
-    if {"" ne $with_tcl} {
-      # Ensure that we can find tclConfig.sh under ${with_tcl}/...
-      if {$doConfigLookup} {
-        if {[file readable "${with_tcl}/tclConfig.sh"]} {
-          set cfg "${with_tcl}/tclConfig.sh"
-        } else {
-          foreach i $tclSubdirs {
-            if {[file readable "${with_tcl}/$i/tclConfig.sh"]} {
-              set cfg "${with_tcl}/$i/tclConfig.sh"
-              break
-            }
-          }
-        }
-      }
-      if {"" eq $cfg} {
-        proj-fatal "No tclConfig.sh found under ${with_tcl}"
-      }
-    } else {
-      # If we have not yet found a tclConfig.sh file, look in $libdir
-      # which is set automatically by autosetup or via the --prefix
-      # command-line option.  See
-      # https://sqlite.org/forum/forumpost/e04e693439a22457
-      set libdir [get-define libdir]
-      if {[file readable "${libdir}/tclConfig.sh"]} {
-        set cfg "${libdir}/tclConfig.sh"
-      } else {
-        foreach i $tclSubdirs {
-          if {[file readable "${libdir}/$i/tclConfig.sh"]} {
-            set cfg "${libdir}/$i/tclConfig.sh"
-            break
-          }
-        }
-      }
-      if {![file readable $cfg]} {
-        break
-      }
-    }
-    msg-result "Using tclConfig.sh: $cfg"
-    break
-  }
-  define TCL_CONFIG_SH $cfg
-  # Export a subset of tclConfig.sh to the current TCL-space.  If $cfg
-  # is an empty string, this emits empty-string entries for the
-  # various options we're interested in.
-  proj-tclConfig-sh-to-autosetup $cfg
-
-  if {"" eq $with_tclsh && $cfg ne ""} {
-    # We have tclConfig.sh but no tclsh. Attempt to locate a tclsh
-    # based on info from tclConfig.sh.
-    set tclExecPrefix [get-define TCL_EXEC_PREFIX]
-    proj-assert {"" ne $tclExecPrefix}
-    set tryThese [list \
-                    $tclExecPrefix/bin/tclsh[get-define TCL_VERSION] \
-                    $tclExecPrefix/bin/tclsh ]
-    foreach trySh $tryThese {
-      if {[file-isexec $trySh]} {
-        set with_tclsh $trySh
-        break
-      }
-    }
-    if {![file-isexec $with_tclsh]} {
-      proj-warn "Cannot find a usable tclsh (tried: $tryThese)
-    }
-  }
-  define TCLSH_CMD $with_tclsh
-  if {$use_tcl} {
-    # Set up the TCLLIBDIR
-    #
-    # 2024-10-28: calculation of TCLLIBDIR is now done via the shell
-    # in main.mk (search it for T.tcl.env.sh) so that
-    # static/hand-written makefiles which import main.mk do not have
-    # to define that before importing main.mk. Even so, we export
-    # TCLLIBDIR from here, which will cause the canonical makefile to
-    # use this one rather than to re-calculate it at make-time.
-    set tcllibdir [get-env TCLLIBDIR ""]
-    set sq3Ver [get-define PACKAGE_VERSION]
-    if {"" eq $tcllibdir} {
-      # Attempt to extract TCLLIBDIR from TCL's $auto_path
-      if {"" ne $with_tclsh &&
-          [catch {exec echo "puts stdout \$auto_path" | "$with_tclsh"} result] == 0} {
-        foreach i $result {
-          if {[file isdir $i]} {
-            set tcllibdir $i/sqlite${sq3Ver}
-            break
-          }
-        }
-      } else {
-        proj-warn "Cannot determine TCLLIBDIR."
-        # The makefile will fail fatally in this case if a target is
-        # invoked which requires TCLLIBDIR.
-      }
-    }
-    #if {"" ne $tcllibdir} { msg-result "TCLLIBDIR = ${tcllibdir}"; }
-    define TCLLIBDIR $tcllibdir
-  }; # find TCLLIBDIR
-
-  if {[file-isexec $with_tclsh]} {
-    msg-result "Using tclsh: $with_tclsh"
-    if {$cfg ne ""} {
-      define HAVE_TCL 1
-    } else {
-      proj-warn "Found tclsh but no tclConfig.sh."
-    }
-  }
-  show-notices
-  # If TCL is not found: if it was explicitly requested then fail
-  # fatally, else just emit a warning. If we can find the APIs needed
-  # to generate a working JimTCL then that will suffice for build-time
-  # TCL purposes (see: proc sqlite-determine-codegen-tcl).
-  if {![get-define HAVE_TCL] &&
-      ([proj-opt-was-provided tcl] || [proj-opt-was-provided with-tcl])} {
-    proj-fatal "TCL support was requested but no tclConfig.sh could be found."
-  }
-  if {"" eq $cfg} {
-    proj-assert {0 == [get-define HAVE_TCL]}
-    proj-indented-notice {
-      WARNING: Cannot find a usable tclConfig.sh file.  Use
-      --with-tcl=DIR to specify a directory where tclConfig.sh can be
-      found.  SQLite does not use TCL internally, but some optional
-      components require TCL, including tests and sqlite3_analyzer.
-    }
-  }
-}; # sqlite-check-tcl
-
-########################################################################
-# sqlite-determine-codegen-tcl checks which TCL to use as a code
-# generator.  By default, prefer jimsh simply because we have it
-# in-tree (it's part of autosetup) unless --with-tclsh=X is used, in
-# which case prefer X.
-#
-# Returns the human-readable name of the TCL it selects. Fails fatally
-# if it cannot detect a TCL appropriate for code generation.
-#
-# Defines:
-#
-#   - BTCLSH = the TCL shell used for code generation. It may set this
-#     to an unexpanded makefile var name.
-#
-#   - CFLAGS_JIMSH = any flags needed for buildng a BTCLSH-compatible
-#     jimsh. The defaults may be passed on to configure as
-#     CFLAGS_JIMSH=...
-proc sqlite-determine-codegen-tcl {} {
-  msg-result "Checking for TCL to use for code generation... "
-  define CFLAGS_JIMSH [proj-get-env CFLAGS_JIMSH {-O1}]
-  set cgtcl [opt-val with-tclsh jimsh]
-  if {"jimsh" ne $cgtcl} {
-    # When --with-tclsh=X is used, use that for all TCL purposes,
-    # including in-tree code generation, per developer request.
-    define BTCLSH "\$(TCLSH_CMD)"
-    return $cgtcl
-  }
-  set flagsToRestore {CC CFLAGS AS_CFLAGS CPPFLAGS AS_CPPFLAGS LDFLAGS LINKFLAGS LIBS CROSS}
-  define-push $flagsToRestore {
-    # We have to swap CC to CC_FOR_BUILD for purposes of the various
-    # [cc-...] tests below. Recall that --with-wasi-sdk may have
-    # swapped out CC with one which is not appropriate for this block.
-    # Per consulation with autosetup's creator, doing this properly
-    # requires us to [define-push] the whole $flagsToRestore list
-    # (plus a few others which are not relevant in this tree).
-    #
-    # These will get set to their previous values at the end of this
-    # block.
-    foreach flag $flagsToRestore {define $flag ""}
-    define CC [get-define CC_FOR_BUILD]
-    # These headers are technically optional for JimTCL but necessary if
-    # we want to use it for code generation:
-    set sysh [cc-check-includes dirent.h sys/time.h]
-    # jimsh0.c hard-codes #define's for HAVE_DIRENT_H and
-    # HAVE_SYS_TIME_H on the platforms it supports, so we do not
-    # need to add -D... flags for those. We check for them here only
-    # so that we can avoid the situation that we later, at
-    # make-time, try to compile jimsh but it then fails due to
-    # missing headers (i.e. fail earlier rather than later).
-    if {$sysh && [cc-check-functions realpath]} {
-      define-append CFLAGS_JIMSH -DHAVE_REALPATH
-      define BTCLSH "\$(JIMSH)"
-      set ::sqliteConfig(use-jim-for-codegen) 1
-    } elseif {$sysh && [cc-check-functions _fullpath]} {
-      # _fullpath() is a Windows API. It's not entirely clear
-      # whether we need to add {-DHAVE_SYS_TIME_H -DHAVE_DIRENT_H}
-      # to CFLAGS_JIMSH in this case. On MinGW32 we definitely do
-      # not want to because it already hard-codes them. On _MSC_VER
-      # builds it does not.
-      define-append CFLAGS_JIMSH -DHAVE__FULLPATH
-      define BTCLSH "\$(JIMSH)"
-      set ::sqliteConfig(use-jim-for-codegen) 1
-    } elseif {[file-isexec [get-define TCLSH_CMD]]} {
-      set cgtcl [get-define TCLSH_CMD]
-      define BTCLSH "\$(TCLSH_CMD)"
-    } else {
-      # One last-ditch effort to find TCLSH_CMD: use info from
-      # tclConfig.sh to try to find a tclsh
-      if {"" eq [get-define TCLSH_CMD]} {
-        set tpre [get-define TCL_EXEC_PREFIX]
-        if {"" ne $tpre} {
-          set tv [get-define TCL_VERSION]
-          if {[file-isexec "${tpre}/bin/tclsh${tv}"]} {
-            define TCLSH_CMD "${tpre}/bin/tclsh${tv}"
-          } elseif {[file-isexec "${tpre}/bin/tclsh"]} {
-            define TCLSH_CMD "${tpre}/bin/tclsh"
-          }
-        }
-      }
-      set cgtcl [get-define TCLSH_CMD]
-      if {![file-isexec $cgtcl]} {
-        proj-fatal "Cannot find a tclsh to use for code generation."
-      }
-      define BTCLSH "\$(TCLSH_CMD)"
-    }
-  }; # /define-push $flagsToRestore
-  return $cgtcl
-}; # sqlite-determine-codegen-tcl
-
-########################################################################
-# Runs sqlite-check-tcl and, if this is the canonical build,
-# sqlite-determine-codegen-tcl.
-proc sqlite-handle-tcl {} {
-  sqlite-check-tcl
-  if {"canonical" ne $::sqliteConfig(build-mode)} return
-  msg-result "TCL for code generation: [sqlite-determine-codegen-tcl]"
-
-  # Determine the base name of the Tcl extension's DLL
-  #
-  if {[get-define HAVE_TCL]} {
-    if {[string match *-cygwin [get-define host]]} {
-      set libname cyg
-    } else {
-      set libname lib
-    }
-    if {[get-define TCL_MAJOR_VERSION] > 8} {
-      append libname tcl9
-    }
-    append libname sqlite
-  } else {
-    set libname ""
-  }
-  define TCL_EXT_DLL_BASENAME $libname
-  # The extension is added in the makefile
-}
-
-########################################################################
-# Handle the --enable/disable-rpath flag.
-proc sqlite-handle-rpath {} {
-  # autosetup/cc-shared.tcl sets the rpath flag definition in
-  # [get-define SH_LINKRPATH], but it does so on a per-platform basis
-  # rather than as a compiler check. Though we should do a proper
-  # compiler check (as proj-check-rpath does), we may want to consider
-  # adopting its approach of clearing the rpath flags for environments
-  # for which sqlite-env-is-unix-on-windows returns a non-empty
-  # string.
-
-  # https://sqlite.org/forum/forumpost/13cac3b56516f849
-  if {[proj-opt-truthy rpath]} {
-    proj-check-rpath
-  } else {
-    msg-result "Disabling use of rpath."
-    define LDFLAGS_RPATH ""
-  }
-}
-
-########################################################################
-# If the --dump-defines configure flag is provided then emit a list of
-# all [define] values to config.defines.txt, else do nothing.
-proc sqlite-dump-defines {} {
-  proj-if-opt-truthy dump-defines {
-    make-config-header $::sqliteConfig(dump-defines-txt) \
-      -bare {SQLITE_OS* SQLITE_DEBUG USE_*} \
-      -str {BIN_* CC LD AR LDFLAG* OPT_*} \
-      -auto {*}
-    # achtung: ^^^^ whichever SQLITE_OS_foo flag which is set to 0 will
-    # get _undefined_ here unless it's part of the -bare set.
-    if {"" ne $::sqliteConfig(dump-defines-json)} {
-      msg-result "--dump-defines is creating $::sqliteConfig(dump-defines-json)"
-      ########################################################################
-      # Dump config-defines.json...
-      # Demonstrate (mis?)handling of spaces in JSON-export array values:
-      # define-append OPT_FOO.list {"-DFOO=bar baz" -DBAR="baz barre"}
-      define OPT_FEATURE_FLAGS.list [get-define OPT_FEATURE_FLAGS]
-      define OPT_SHELL.list [get-define OPT_SHELL]
-      set dumpDefsOpt {
-        -bare {SIZEOF_* HAVE_DECL_*}
-        -none {HAVE_CFLAG_* LDFLAGS_* SH_* SQLITE_AUTORECONFIG TARGET_* USE_GCOV TCL_*}
-        -array {*.list}
-        -auto {OPT_* PACKAGE_* HAVE_*}
-      }
-#      if {$::sqliteConfig(dump-defines-json-include-lowercase)} {
-#        lappend dumpDefsOpt -none {lib_*} ; # remnants from proj-check-function-in-lib and friends
-#        lappend dumpDefsOpt -auto {[a-z]*}
-#      }
-      lappend dumpDefsOpt -none *
-      proj-dump-defs-json $::sqliteConfig(dump-defines-json) {*}$dumpDefsOpt
-      undefine OPT_FEATURE_FLAGS.list
-      undefine OPT_SHELL.list
-    }
-  }
-}
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/system.tcl b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/system.tcl
deleted file mode 100644
index 05d378a..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/system.tcl
+++ /dev/null
@@ -1,420 +0,0 @@
-# Copyright (c) 2010 WorkWare Systems http://www.workware.net.au/
-# All rights reserved
-
-# @synopsis:
-#
-# This module supports common system interrogation and options
-# such as '--host', '--build', '--prefix', and setting 'srcdir', 'builddir', and 'EXEEXT'.
-#
-# It also support the "feature" naming convention, where searching
-# for a feature such as 'sys/type.h' defines 'HAVE_SYS_TYPES_H'.
-#
-# It defines the following variables, based on '--prefix' unless overridden by the user:
-#
-## datadir
-## sysconfdir
-## sharedstatedir
-## localstatedir
-## infodir
-## mandir
-## includedir
-#
-# If '--prefix' is not supplied, it defaults to '/usr/local' unless 'options-defaults { prefix ... }' is used *before*
-# including the 'system' module.
-
-if {[is-defined defaultprefix]} {
-	user-notice "Note: defaultprefix is deprecated. Use options-defaults to set default options"
-	options-defaults [list prefix [get-define defaultprefix]]
-}
-
-options {
-	host:host-alias =>		{a complete or partial cpu-vendor-opsys for the system where
-							the application will run (defaults to the same value as --build)}
-	build:build-alias =>	{a complete or partial cpu-vendor-opsys for the system
-							where the application will be built (defaults to the
-							result of running config.guess)}
-	prefix:dir=/usr/local => {the target directory for the build (default: '@default@')}
-
-	# These (hidden) options are supported for autoconf/automake compatibility
-	exec-prefix:
-	bindir:
-	sbindir:
-	includedir:
-	mandir:
-	infodir:
-	libexecdir:
-	datadir:
-	libdir:
-	sysconfdir:
-	sharedstatedir:
-	localstatedir:
-	runstatedir:
-	maintainer-mode=0
-	dependency-tracking=0
-	silent-rules=0
-	program-prefix:
-	program-suffix:
-	program-transform-name:
-	x-includes:
-	x-libraries:
-}
-
-# @check-feature name { script }
-#
-# defines feature '$name' to the return value of '$script',
-# which should be 1 if found or 0 if not found.
-#
-# e.g. the following will define 'HAVE_CONST' to 0 or 1.
-#
-## check-feature const {
-##     cctest -code {const int _x = 0;}
-## }
-proc check-feature {name code} {
-	msg-checking "Checking for $name..."
-	set r [uplevel 1 $code]
-	define-feature $name $r
-	if {$r} {
-		msg-result "ok"
-	} else {
-		msg-result "not found"
-	}
-	return $r
-}
-
-# @have-feature name ?default=0?
-#
-# Returns the value of feature '$name' if defined, or '$default' if not.
-#
-# See 'feature-define-name' for how the "feature" name
-# is translated into the "define" name.
-#
-proc have-feature {name {default 0}} {
-	get-define [feature-define-name $name] $default
-}
-
-# @define-feature name ?value=1?
-#
-# Sets the feature 'define' to '$value'.
-#
-# See 'feature-define-name' for how the "feature" name
-# is translated into the "define" name.
-#
-proc define-feature {name {value 1}} {
-	define [feature-define-name $name] $value
-}
-
-# @feature-checked name
-#
-# Returns 1 if feature '$name' has been checked, whether true or not.
-#
-proc feature-checked {name} {
-	is-defined [feature-define-name $name]
-}
-
-# @feature-define-name name ?prefix=HAVE_?
-#
-# Converts a "feature" name to the corresponding "define",
-# e.g. 'sys/stat.h' becomes 'HAVE_SYS_STAT_H'.
-#
-# Converts '*' to 'P' and all non-alphanumeric to underscore.
-#
-proc feature-define-name {name {prefix HAVE_}} {
-	string toupper $prefix[regsub -all {[^a-zA-Z0-9]} [regsub -all {[*]} $name p] _]
-}
-
-# @write-if-changed filename contents ?script?
-#
-# If '$filename' doesn't exist, or it's contents are different to '$contents',
-# the file is written and '$script' is evaluated.
-#
-# Otherwise a "file is unchanged" message is displayed.
-proc write-if-changed {file buf {script {}}} {
-	set old [readfile $file ""]
-	if {$old eq $buf && [file exists $file]} {
-		msg-result "$file is unchanged"
-	} else {
-		writefile $file $buf\n
-		uplevel 1 $script
-	}
-}
-
-
-# @include-file infile mapping
-#
-# The core of make-template, called recursively for each @include
-# directive found within that template so that this proc's result
-# is the fully-expanded template.
-#
-# The mapping parameter is how we expand @varname@ within the template.
-# We do that inline within this step only for @include directives which
-# can have variables in the filename arg.  A separate substitution pass
-# happens when this recursive function returns, expanding the rest of
-# the variables.
-#
-proc include-file {infile mapping} {
-	# A stack of true/false conditions, one for each nested conditional
-	# starting with "true"
-	set condstack {1}
-	set result {}
-	set linenum 0
-	foreach line [split [readfile $infile] \n] {
-		incr linenum
-		if {[regexp {^@(if|else|endif)(\s*)(.*)} $line -> condtype condspace condargs]} {
-			if {$condtype eq "if"} {
-				if {[string length $condspace] == 0} {
-					autosetup-error "$infile:$linenum: Invalid expression: $line"
-				}
-				if {[llength $condargs] == 1} {
-					# ABC => [get-define ABC] ni {0 ""}
-					# !ABC => [get-define ABC] in {0 ""}
-					lassign $condargs condvar
-					if {[regexp {^!(.*)} $condvar -> condvar]} {
-						set op in
-					} else {
-						set op ni
-					}
-					set condexpr "\[[list get-define $condvar]\] $op {0 {}}"
-				} else {
-					# Translate alphanumeric ABC into [get-define ABC] and leave the
-					# rest of the expression untouched
-					regsub -all {([A-Z][[:alnum:]_]*)} $condargs {[get-define \1]} condexpr
-				}
-				if {[catch [list expr $condexpr] condval]} {
-					dputs $condval
-					autosetup-error "$infile:$linenum: Invalid expression: $line"
-				}
-				dputs "@$condtype: $condexpr => $condval"
-			}
-			if {$condtype ne "if"} {
-				if {[llength $condstack] <= 1} {
-					autosetup-error "$infile:$linenum: Error: @$condtype missing @if"
-				} elseif {[string length $condargs] && [string index $condargs 0] ne "#"} {
-					autosetup-error "$infile:$linenum: Error: Extra arguments after @$condtype"
-				}
-			}
-			switch -exact $condtype {
-				if {
-					# push condval
-					lappend condstack $condval
-				}
-				else {
-					# Toggle the last entry
-					set condval [lpop condstack]
-					set condval [expr {!$condval}]
-					lappend condstack $condval
-				}
-				endif {
-					if {[llength $condstack] == 0} {
-						user-notice "$infile:$linenum: Error: @endif missing @if"
-					}
-					lpop condstack
-				}
-			}
-			continue
-		}
-		# Only continue if the stack contains all "true"
-		if {"0" in $condstack} {
-			continue
-		}
-		if {[regexp {^@include\s+(.*)} $line -> filearg]} {
-			set incfile [string map $mapping $filearg]
-			if {[file exists $incfile]} {
-				lappend ::autosetup(deps) [file-normalize $incfile]
-				lappend result {*}[include-file $incfile $mapping]
-			} else {
-				user-error "$infile:$linenum: Include file $incfile is missing"
-			}
-			continue
-		}
-		if {[regexp {^@define\s+(\w+)\s+(.*)} $line -> var val]} {
-			define $var $val
-			continue
-		}
-		lappend result $line
-	}
-	return $result
-}
-
-
-# @make-template template ?outfile?
-#
-# Reads the input file '<srcdir>/$template' and writes the output file '$outfile'
-# (unless unchanged).
-# If '$outfile' is blank/omitted, '$template' should end with '.in' which
-# is removed to create the output file name.
-#
-# Each pattern of the form '@define@' is replaced with the corresponding
-# "define", if it exists, or left unchanged if not.
-#
-# The special value '@srcdir@' is substituted with the relative
-# path to the source directory from the directory where the output
-# file is created, while the special value '@top_srcdir@' is substituted
-# with the relative path to the top level source directory.
-#
-# Conditional sections may be specified as follows:
-## @if NAME eq "value"
-## lines
-## @else
-## lines
-## @endif
-#
-# Where 'NAME' is a defined variable name and '@else' is optional.
-# Note that variables names *must* start with an uppercase letter.
-# If the expression does not match, all lines through '@endif' are ignored.
-#
-# The alternative forms may also be used:
-## @if NAME  (true if the variable is defined, but not empty and not "0")
-## @if !NAME  (opposite of the form above)
-## @if <general-tcl-expression>
-#
-# In the general Tcl expression, any words beginning with an uppercase letter
-# are translated into [get-define NAME]
-#
-# Expressions may be nested
-#
-proc make-template {template {out {}}} {
-	set infile [file join $::autosetup(srcdir) $template]
-
-	if {![file exists $infile]} {
-		user-error "Template $template is missing"
-	}
-
-	# Define this as late as possible
-	define AUTODEPS $::autosetup(deps)
-
-	if {$out eq ""} {
-		if {[file ext $template] ne ".in"} {
-			autosetup-error "make_template $template has no target file and can't guess"
-		}
-		set out [file rootname $template]
-	}
-
-	set outdir [file dirname $out]
-
-	# Make sure the directory exists
-	file mkdir $outdir
-
-	# Set up srcdir and top_srcdir to be relative to the target dir
-	define srcdir [relative-path [file join $::autosetup(srcdir) $outdir] $outdir]
-	define top_srcdir [relative-path $::autosetup(srcdir) $outdir]
-
-	# Build map from global defines to their values so they can be
-	# substituted into @include file names.
-	proc build-define-mapping {} {
-		set mapping {}
-		foreach {n v} [array get ::define] {
-			lappend mapping @$n@ $v
-		}
-		return $mapping
-	}
-	set mapping [build-define-mapping]
-
-	set result [include-file $infile $mapping]
-
-	# Rebuild the define mapping in case we ran across @define
-	# directives in the template or a file it @included, then
-	# apply that mapping to the expanded template.
-	set mapping [build-define-mapping]
-	write-if-changed $out [string map $mapping [join $result \n]] {
-		msg-result "Created [relative-path $out] from [relative-path $template]"
-	}
-}
-
-proc system-init {} {
-	global autosetup
-
-	# build/host tuples and cross-compilation prefix
-	opt-str build build ""
-	define build_alias $build
-	if {$build eq ""} {
-		define build [config_guess]
-	} else {
-		define build [config_sub $build]
-	}
-
-	opt-str host host ""
-	define host_alias $host
-	if {$host eq ""} {
-		define host [get-define build]
-		set cross ""
-	} else {
-		define host [config_sub $host]
-		set cross $host-
-	}
-	define cross [get-env CROSS $cross]
-
-	# build/host _cpu, _vendor and _os
-	foreach type {build host} {
-		set v [get-define $type]
-		if {![regexp {^([^-]+)-([^-]+)-(.*)$} $v -> cpu vendor os]} {
-			user-error "Invalid canonical $type: $v"
-		}
-		define ${type}_cpu $cpu
-		define ${type}_vendor $vendor
-		define ${type}_os $os
-	}
-
-	opt-str prefix prefix /usr/local
-
-	# These are for compatibility with autoconf
-	define target [get-define host]
-	define prefix $prefix
-	define builddir $autosetup(builddir)
-	define srcdir $autosetup(srcdir)
-	define top_srcdir $autosetup(srcdir)
-	define abs_top_srcdir [file-normalize $autosetup(srcdir)]
-	define abs_top_builddir [file-normalize $autosetup(builddir)]
-
-	# autoconf supports all of these
-	define exec_prefix [opt-str exec-prefix exec_prefix $prefix]
-	foreach {name defpath} {
-		bindir /bin
-		sbindir /sbin
-		libexecdir /libexec
-		libdir /lib
-	} {
-		define $name [opt-str $name o $exec_prefix$defpath]
-	}
-	foreach {name defpath} {
-		datadir /share
-		sharedstatedir /com
-		infodir /share/info
-		mandir /share/man
-		includedir /include
-	} {
-		define $name [opt-str $name o $prefix$defpath]
-	}
-	if {$prefix ne {/usr}} {
-		opt-str sysconfdir sysconfdir $prefix/etc
-	} else {
-		opt-str sysconfdir sysconfdir /etc
-	}
-	define sysconfdir $sysconfdir
-
-	define localstatedir [opt-str localstatedir o /var]
-	define runstatedir [opt-str runstatedir o /run]
-
-	define SHELL [get-env SHELL [find-an-executable sh bash ksh]]
-
-	# These could be used to generate Makefiles following some automake conventions
-	define AM_SILENT_RULES [opt-bool silent-rules]
-	define AM_MAINTAINER_MODE [opt-bool maintainer-mode]
-	define AM_DEPENDENCY_TRACKING [opt-bool dependency-tracking]
-
-	# Windows vs. non-Windows
-	switch -glob -- [get-define host] {
-		*-*-ming* - *-*-cygwin - *-*-msys {
-			define-feature windows
-			define EXEEXT .exe
-		}
-		default {
-			define EXEEXT ""
-		}
-	}
-
-	# Display
-	msg-result "Host System...[get-define host]"
-	msg-result "Build System...[get-define build]"
-}
-
-system-init
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/teaish/README.txt b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/teaish/README.txt
deleted file mode 100644
index e11519b..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/teaish/README.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-The *.tcl files in this directory are part of the SQLite's "autoconf"
-bundle which are specific to the TEA(-ish) build. During the tarball
-generation process, they are copied into <TOP>/autoconf/autosetup/teaish
-(which itself is created as part of that process).
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/teaish/core.tcl b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/teaish/core.tcl
deleted file mode 100644
index c9abfa0..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/teaish/core.tcl
+++ /dev/null
@@ -1,2564 +0,0 @@
-########################################################################
-# 2025 April 5
-#
-# The author disclaims copyright to this source code.  In place of
-# a legal notice, here is a blessing:
-#
-#  * May you do good and not evil.
-#  * May you find forgiveness for yourself and forgive others.
-#  * May you share freely, never taking more than you give.
-#
-########################################################################
-# ----- @module teaish.tcl -----
-# @section TEA-ish ((TCL Extension Architecture)-ish)
-#
-# Functions in this file with a prefix of teaish__ are
-# private/internal APIs. Those with a prefix of teaish- are
-# public APIs.
-#
-# Teaish has a hard dependency on proj.tcl, and any public API members
-# of that module are considered legal for use by teaish extensions.
-#
-# Project home page: https://fossil.wanderinghorse.net/r/teaish
-
-use proj
-
-#
-# API-internal settings and shared state.
-array set teaish__Config [proj-strip-hash-comments {
-  #
-  # Teaish's version number, not to be confused with
-  # teaish__PkgInfo(-version).
-  #
-  version 0.1-beta
-
-  # set to 1 to enable some internal debugging output
-  debug-enabled 0
-
-  #
-  # 0     = don't yet have extension's pkgindex
-  # 0x01  = found TEAISH_EXT_DIR/pkgIndex.tcl.in
-  # 0x02  = found srcdir/pkgIndex.tcl.in
-  # 0x10  = found TEAISH_EXT_DIR/pkgIndex.tcl (static file)
-  # 0x20  = static-pkgIndex.tcl pragma: behave as if 0x10
-  # 0x100 = disabled by -tm.tcl.in
-  # 0x200 = disabled by -tm.tcl
-  #
-  # Reminder: it's significant that the bottom 4 bits be
-  # cases where teaish manages ./pkgIndex.tcl.
-  #
-  pkgindex-policy 0
-
-  #
-  # The pkginit counterpart of pkgindex-policy:
-  #
-  # 0    = no pkginit
-  # 0x01 = found default X.in: generate X from X.in
-  # 0x10 = found static pkginit file X
-  # 0x02 = user-provided X.in generates ./X.
-  # 0x20 = user-provided static pkginit file X
-  #
-  # The 0x0f bits indicate that teaish is responsible for cleaning up
-  # the (generated) pkginit file.
-  #
-  pkginit-policy 0
-  #
-  # 0    = no tm.tcl
-  # 0x01 = tm.tcl.in
-  # 0x10 = static tm.tcl
-  tm-policy 0
-
-  #
-  # If 1+ then teaish__verbose will emit messages.
-  #
-  verbose 0
-
-  #
-  # Mapping of pkginfo -flags to their TEAISH_xxx define (if any).
-  # This must not be modified after initialization.
-  #
-  pkginfo-f2d {
-    -name            TEAISH_NAME
-    -name.dist       TEAISH_DIST_NAME
-    -name.pkg        TEAISH_PKGNAME
-    -version         TEAISH_VERSION
-    -libDir          TEAISH_LIBDIR_NAME
-    -loadPrefix      TEAISH_LOAD_PREFIX
-    -vsatisfies      TEAISH_VSATISFIES
-    -pkgInit.tcl     TEAISH_PKGINIT_TCL
-    -pkgInit.tcl.in  TEAISH_PKGINIT_TCL_IN
-    -url             TEAISH_URL
-    -tm.tcl          TEAISH_TM_TCL
-    -tm.tcl.in       TEAISH_TM_TCL_IN
-    -options         {}
-    -pragmas         {}
-    -src             {}
-  }
-
-  #
-  # Queues for use with teaish-checks-queue and teaish-checks-run.
-  #
-  queued-checks-pre {}
-  queued-checks-post {}
-
-  # Whether or not "make dist" parts are enabled. They get enabled
-  # when building from an extension's dir, disabled when building
-  # elsewhere.
-  dist-enabled 1
-  # Whether or not "make install" parts are enabled. By default
-  # they are, but we have a single use case where they're
-  # both unnecessary and unhelpful, so...
-  install-enabled 1
-
-  # By default we enable compilation of a native extension but if the
-  # extension has no native code or the user wants to take that over
-  # via teaish.make.in or provide a script-only extension, we will
-  # elide the default compilation rules if this is 0.
-  dll-enabled 1
-
-  # Files to include in the "make dist" bundle.
-  dist-files {}
-
-  # List of source files for the extension.
-  extension-src {}
-
-  # Path to the teaish.tcl file.
-  teaish.tcl {}
-
-  # Dir where teaish.tcl is found.
-  extension-dir {}
-
-  # Whether the generates TEASH_VSATISFIES_CODE should error out on a
-  # satisfies error. If 0, it uses return instead of error.
-  vsatisfies-error 1
-
-  # Whether or not to allow a "full dist" - a "make dist" build which
-  # includes both the extension and teaish. By default this is only on
-  # if the extension dir is teaish's dir.
-  dist-full-enabled 0
-}]
-set teaish__Config(core-dir) $::autosetup(libdir)/teaish
-
-#
-# Array of info managed by teaish-pkginfo-get and friends.  Has the
-# same set of keys as $teaish__Config(pkginfo-f2d).
-#
-array set teaish__PkgInfo {}
-
-#
-# Runs {*}$args if $lvl is <= the current verbosity level, else it has
-# no side effects.
-#
-proc teaish__verbose {lvl args} {
-  if {$lvl <= $::teaish__Config(verbose)} {
-    {*}$args
-  }
-}
-
-#
-# @teaish-argv-has flags...
-#
-# Returns true if any arg in $::argv matches any of the given globs,
-# else returns false.
-#
-proc teaish-argv-has {args} {
-  foreach glob $args {
-    foreach arg $::argv {
-      if {[string match $glob $arg]} {
-        return 1
-      }
-    }
-  }
-  return 0
-}
-
-if {[teaish-argv-has --teaish-verbose --t-v]} {
-  # Check this early so that we can use verbose-only messages in the
-  # pre-options-parsing steps.
-  set ::teaish__Config(verbose) 1
-  #teaish__verbose 1 msg-result "--teaish-verbose activated"
-}
-
-msg-quiet use system ; # Outputs "Host System" and "Build System" lines
-if {"--help" ni $::argv} {
-  teaish__verbose 1 msg-result "TEA(ish) Version = $::teaish__Config(version)"
-  teaish__verbose 1 msg-result "Source dir       = $::autosetup(srcdir)"
-  teaish__verbose 1 msg-result "Build dir        = $::autosetup(builddir)"
-}
-
-#
-# @teaish-configure-core
-#
-# Main entry point for the TEA-ish configure process. auto.def's primary
-# (ideally only) job should be to call this.
-#
-proc teaish-configure-core {} {
-  proj-tweak-default-env-dirs
-
-  set ::teaish__Config(install-mode) [teaish-argv-has --teaish-install*]
-  set ::teaish__Config(create-ext-mode) \
-    [teaish-argv-has --teaish-create-extension=* --t-c-e=*]
-  set gotExt 0; # True if an extension config is found
-  if {!$::teaish__Config(create-ext-mode)
-      && !$::teaish__Config(install-mode)} {
-    # Don't look for an extension if we're in --t-c-e or --t-i mode
-    set gotExt [teaish__find_extension]
-  }
-
-  #
-  # Set up the core --flags. This needs to come before teaish.tcl is
-  # sourced so that that file can use teaish-pkginfo-set to append
-  # options.
-  #
-  options-add [proj-strip-hash-comments {
-    with-tcl:DIR
-      => {Directory containing tclConfig.sh or a directory one level up from
-          that, from which we can derive a directory containing tclConfig.sh.
-          Defaults to the $TCL_HOME environment variable.}
-
-    with-tclsh:PATH
-      => {Full pathname of tclsh to use.  It is used for trying to find
-          tclConfig.sh.  Warning: if its containing dir has multiple tclsh
-          versions, it may select the wrong tclConfig.sh!
-        Defaults to the $TCLSH environment variable.}
-
-    tcl-stubs=0 => {Enable use of Tcl stubs library.}
-
-    # TEA has --with-tclinclude but it appears to only be useful for
-    # building an extension against an uninstalled copy of TCL's own
-    # source tree. The policy here is that either we get that info
-    # from tclConfig.sh or we give up.
-    #
-    # with-tclinclude:DIR
-    #   => {Specify the directory which contains the tcl.h. This should not
-    #       normally be required, as that information comes from tclConfig.sh.}
-
-    # We _generally_ want to reduce the possibility of flag collisions with
-    # extensions, and thus use a teaish-... prefix on most flags. However,
-    # --teaish-extension-dir is frequently needed, so...
-    #
-    # As of this spontaneous moment, we'll settle on using --t-A-X to
-    # abbreviate --teaish-A...-X... flags when doing so is
-    # unambiguous...
-    ted: t-e-d:
-    teaish-extension-dir:DIR
-      => {Looks for an extension in the given directory instead of the current
-          dir.}
-
-    t-c-e:
-    teaish-create-extension:TARGET_DIRECTORY
-      => {Writes stub files for creating an extension. Will refuse to overwrite
-          existing files without --teaish-force.}
-
-    t-f
-    teaish-force
-      => {Has a context-dependent meaning (autosetup defines --force for its
-          own use).}
-
-    t-d-d
-    teaish-dump-defines
-      => {Dump all configure-defined vars to config.defines.txt}
-
-    t-v:=0
-    teaish-verbose:=0
-      => {Enable more (often extraneous) messages from the teaish core.}
-
-    t-d
-    teaish-debug=0 => {Enable teaish-specific debug output}
-
-    t-i
-    teaish-install:=auto
-      => {Installs a copy of teaish, including autosetup, to the target dir.
-          When used with --teaish-create-extension=DIR, a value of "auto"
-          (no no value) will inherit that directory.}
-
-    #TODO: --teaish-install-extension:=dir as short for
-    # --t-c-e=dir --t-i
-
-    t-e-p:
-    teaish-extension-pkginfo:pkginfo
-      => {For use with --teaish-create-extension. If used, it must be a
-          list of arguments for use with teaish-pkginfo-set, e.g.
-          --teaish-extension-pkginfo="-name Foo -version 2.3"}
-
-    t-v-c
-    teaish-vsatisfies-check=1
-      => {Disable the configure-time "vsatisfies" check on the target tclsh.}
-
-  }]; # main options.
-
-  if {$gotExt} {
-    # We found an extension. Source it...
-    set ttcl $::teaish__Config(teaish.tcl)
-    proj-assert {"" ne [teaish-pkginfo-get -name]}
-    proj-assert {[file exists $ttcl]} \
-      "Expecting to have found teaish.(tcl|config) by now"
-    if {[string match *.tcl $ttcl]} {
-      uplevel 1 {source $::teaish__Config(teaish.tcl)}
-    } else {
-      teaish-pkginfo-set {*}[proj-file-content -trim $ttcl]
-    }
-    unset ttcl
-    # Set up some default values if the extension did not set them.
-    # This must happen _after_ it's sourced but before
-    # teaish-configure is called.
-    array set f2d $::teaish__Config(pkginfo-f2d)
-    foreach {pflag key type val} {
-      - TEAISH_CFLAGS            -v ""
-      - TEAISH_LDFLAGS           -v ""
-      - TEAISH_MAKEFILE          -v ""
-      - TEAISH_MAKEFILE_CODE     -v ""
-      - TEAISH_MAKEFILE_IN       -v ""
-      - TEAISH_PKGINDEX_TCL      -v ""
-      - TEAISH_PKGINDEX_TCL_IN   -v ""
-      - TEAISH_PKGINIT_TCL       -v ""
-      - TEAISH_PKGINIT_TCL_IN    -v ""
-      - TEAISH_PKGINIT_TCL_TAIL  -v ""
-      - TEAISH_TEST_TCL          -v ""
-      - TEAISH_TEST_TCL_IN       -v ""
-
-      -version          -       -v 0.0.0
-      -name.pkg         -       -e {set ::teaish__PkgInfo(-name)}
-      -name.dist        -       -e {set ::teaish__PkgInfo(-name)}
-      -libDir           -       -e {
-        join [list \
-                $::teaish__PkgInfo(-name.pkg) \
-                $::teaish__PkgInfo(-version)] ""
-      }
-      -loadPrefix       -       -e {
-        string totitle $::teaish__PkgInfo(-name.pkg)
-      }
-      -vsatisfies       -       -v {{Tcl 8.5-}}
-      -pkgInit.tcl      -       -v ""
-      -pkgInit.tcl.in   -       -v ""
-      -url              -       -v ""
-      -tm.tcl           -       -v ""
-      -tm.tcl.in        -       -v ""
-      -src              -       -v ""
-    } {
-      #proj-assert 0 {Just testing}
-      set isPIFlag [expr {"-" ne $pflag}]
-      if {$isPIFlag} {
-        if {[info exists ::teaish__PkgInfo($pflag)]} {
-          # Was already set - skip it.
-          continue;
-        }
-        proj-assert {{-} eq $key};# "Unexpected pflag=$pflag key=$key type=$type val=$val"
-        set key $f2d($pflag)
-      }
-      if {"" ne $key} {
-        if {"<nope>" ne [get-define $key "<nope>"]} {
-          # Was already set - skip it.
-          continue
-        }
-      }
-      switch -exact -- $type {
-        -v {}
-        -e { set val [eval $val] }
-        default { proj-error "Invalid type flag: $type" }
-      }
-      #puts "***** defining default $pflag $key {$val} isPIFlag=$isPIFlag"
-      if {$key ne ""} {
-        define $key $val
-      }
-      if {$isPIFlag} {
-        set ::teaish__PkgInfo($pflag) $val
-      }
-    }
-    unset isPIFlag pflag key type val
-    array unset f2d
-  }; # sourcing extension's teaish.tcl
-
-  if {[llength [info proc teaish-options]] > 0} {
-    # Add options defined by teaish-options, which is assumed to be
-    # imported via [teaish-get -teaish-tcl].
-    set o [teaish-options]
-    if {"" ne $o} {
-      options-add $o
-    }
-  }
-  #set opts [proj-options-combine]
-  #lappend opts teaish-debug => {x}; #testing dupe entry handling
-  if {[catch {options {}} msg xopts]} {
-    # Workaround for <https://github.com/msteveb/autosetup/issues/73>
-    # where [options] behaves oddly on _some_ TCL builds when it's
-    # called from deeper than the global scope.
-    dict incr xopts -level
-    return {*}$xopts $msg
-  }
-
-  proj-xfer-options-aliases {
-    t-c-e  => teaish-create-extension
-    t-d    => teaish-debug
-    t-d-d  => teaish-dump-defines
-    ted    => teaish-extension-dir
-    t-e-d  => teaish-extension-dir
-    t-e-p  => teaish-extension-pkginfo
-    t-f    => teaish-force
-    t-i    => teaish-install
-    t-v    => teaish-verbose
-    t-v-c  => teaish-vsatisfies-check
-  }
-
-  scan [opt-val teaish-verbose 0] %d ::teaish__Config(verbose)
-  set ::teaish__Config(debug-enabled) [opt-bool teaish-debug]
-
-  set exitEarly 0
-  if {[proj-opt-was-provided teaish-create-extension]} {
-    teaish__create_extension [opt-val teaish-create-extension]
-    incr exitEarly
-  }
-  if {$::teaish__Config(install-mode)} {
-    teaish__install
-    incr exitEarly
-  }
-
-  if {$exitEarly} {
-    file delete -force config.log
-    return
-  }
-  proj-assert {1==$gotExt} "Else we cannot have gotten this far"
-
-  teaish__configure_phase1
-}
-
-
-#
-# Internal config-time debugging output routine. It is not legal to
-# call this from the global scope.
-#
-proc teaish-debug {msg} {
-  if {$::teaish__Config(debug-enabled)} {
-    puts stderr [proj-bold "** DEBUG: \[[proj-scope 1]\]: $msg"]
-  }
-}
-
-#
-# Runs "phase 1" of the configuration, immediately after processing
-# --flags. This is what will import the client-defined teaish.tcl.
-#
-proc teaish__configure_phase1 {} {
-  msg-result \
-    [join [list "Configuring build of Tcl extension" \
-       [proj-bold [teaish-pkginfo-get -name] \
-          [teaish-pkginfo-get -version]] "..."]]
-
-  uplevel 1 {
-    use cc cc-db cc-shared cc-lib; # pkg-config
-  }
-  teaish__check_tcl
-  apply {{} {
-    #
-    # If --prefix or --exec-prefix are _not_ provided, use their
-    # TCL_... counterpart from tclConfig.sh.  Caveat: by the time we can
-    # reach this point, autosetup's system.tcl will have already done
-    # some non-trivial amount of work with these to create various
-    # derived values from them, so we temporarily end up with a mishmash
-    # of autotools-compatibility var values. That will be straightened
-    # out in the final stage of the configure script via
-    # [proj-remap-autoconf-dir-vars].
-    #
-    foreach {flag uflag tclVar} {
-      prefix      prefix      TCL_PREFIX
-      exec-prefix exec_prefix TCL_EXEC_PREFIX
-    } {
-      if {![proj-opt-was-provided $flag]} {
-        if {"exec-prefix" eq $flag} {
-          # If --exec-prefix was not used, ensure that --exec-prefix
-          # derives from the --prefix we may have just redefined.
-          set v {${prefix}}
-        } else {
-          set v [get-define $tclVar "???"]
-          teaish__verbose 1 msg-result "Using \$$tclVar for --$flag=$v"
-        }
-        proj-assert {"???" ne $v} "Expecting teaish__check_tcl to have defined $tclVar"
-        #puts "*** $flag $uflag $tclVar = $v"
-        proj-opt-set $flag $v
-        define $uflag $v
-
-        # ^^^ As of here, all autotools-compatibility vars which derive
-        # from --$flag, e.g. --libdir, still derive from the default
-        # --$flag value which was active when system.tcl was
-        # included. So long as those flags are not explicitly passed to
-        # the configure script, those will be straightened out via
-        # [proj-remap-autoconf-dir-vars].
-      }
-    }
-  }}; # --[exec-]prefix defaults
-  teaish__check_common_bins
-  #
-  # Set up library file names
-  #
-  proj-file-extensions
-  teaish__define_pkginfo_derived *
-
-  teaish-checks-run -pre
-  if {[llength [info proc teaish-configure]] > 0} {
-    # teaish-configure is assumed to be imported via
-    # teaish.tcl
-    teaish-configure
-  }
-  teaish-checks-run -post
-
-  define TEAISH_USE_STUBS [opt-bool tcl-stubs]
-
-  apply {{} {
-    # Set up "vsatisfies" code for pkgIndex.tcl.in,
-    # _teaish.tester.tcl.in, and for a configure-time check.  We would
-    # like to put this before [teaish-checks-run -pre] but it's
-    # marginally conceivable that a client may need to dynamically
-    # calculate the vsatisfies and set it via [teaish-configure].
-    set vs [get-define TEAISH_VSATISFIES ""]
-    if {"" eq $vs} return
-    set code {}
-    set n 0
-    # Treat $vs as a list-of-lists {{Tcl 8.5-} {Foo 1.0- -3.0} ...}
-    # and generate Tcl which will run package vsatisfies tests with
-    # that info.
-    foreach pv $vs {
-      set n [llength $pv]
-      if {$n < 2} {
-        proj-error "-vsatisfies: {$pv} appears malformed. Whole list is: $vs"
-      }
-      set pkg [lindex $pv 0]
-      set vcheck {}
-      for {set i 1} {$i < $n} {incr i} {
-        lappend vcheck [lindex $pv $i]
-      }
-      if {[opt-bool teaish-vsatisfies-check]} {
-        set tclsh [get-define TCLSH_CMD]
-        set vsat "package vsatisfies \[ package provide $pkg \] $vcheck"
-        set vputs "puts \[ $vsat \]"
-        #puts "*** vputs = $vputs"
-        scan [exec echo $vputs | $tclsh] %d vvcheck
-        if {![info exists vvcheck] || 0 == $vvcheck} {
-          proj-fatal -up $tclsh "check failed:" $vsat
-        }
-      }
-      if {$::teaish__Config(vsatisfies-error)} {
-        set vunsat \
-          [list error [list Package \
-                         $::teaish__PkgInfo(-name) $::teaish__PkgInfo(-version) \
-                         requires $pv]]
-      } else {
-        set vunsat return
-      }
-      lappend code \
-        [string trim [subst -nocommands \
-          {if { ![package vsatisfies [package provide $pkg] $vcheck] } {\n  $vunsat\n}}]]
-    }; # foreach pv
-    define TEAISH_VSATISFIES_CODE [join $code "\n"]
-  }}; # vsatisfies
-
-  if {[proj-looks-like-windows]} {
-    # Without this, linking of an extension will not work on Cygwin or
-    # Msys2.
-    msg-result "Using USE_TCL_STUBS for Unix(ish)-on-Windows environment"
-    teaish-cflags-add -DUSE_TCL_STUBS=1
-  }
-
-  #define AS_LIBDIR $::autosetup(libdir)
-  define TEAISH_TESTUTIL_TCL $::teaish__Config(core-dir)/tester.tcl
-
-  apply {{} {
-    #
-    # Ensure we have a pkgIndex.tcl and don't have a stale generated one
-    # when rebuilding for different --with-tcl=... values.
-    #
-    if {!$::teaish__Config(pkgindex-policy)} {
-      proj-error "Cannot determine which pkgIndex.tcl to use"
-    }
-    if {0x300 & $::teaish__Config(pkgindex-policy)} {
-      teaish__verbose 1 msg-result "pkgIndex disabled by -tm.tcl(.in)"
-    } else {
-      set tpi [proj-coalesce \
-                 [get-define TEAISH_PKGINDEX_TCL_IN] \
-                 [get-define TEAISH_PKGINDEX_TCL]]
-      proj-assert {$tpi ne ""} \
-        "TEAISH_PKGINDEX_TCL should have been set up by now"
-      teaish__verbose 1 msg-result "Using pkgIndex from $tpi"
-      if {0x0f & $::teaish__Config(pkgindex-policy)} {
-        # Don't leave stale pkgIndex.tcl laying around yet don't delete
-        # or overwrite a user-managed static pkgIndex.tcl.
-        file delete -force -- [get-define TEAISH_PKGINDEX_TCL]
-        proj-dot-ins-append [get-define TEAISH_PKGINDEX_TCL_IN]
-      } else {
-        teaish-dist-add [file tail $tpi]
-      }
-    }
-  }}; # $::teaish__Config(pkgindex-policy)
-
-  #
-  # Ensure we clean up TEAISH_PKGINIT_TCL if needed and @-process
-  # TEAISH_PKGINIT_TCL_IN if needed.
-  #
-  if {0x0f & $::teaish__Config(pkginit-policy)} {
-    file delete -force -- [get-define TEAISH_PKGINIT_TCL]
-    proj-dot-ins-append [get-define TEAISH_PKGINIT_TCL_IN] \
-      [get-define TEAISH_PKGINIT_TCL]
-  }
-  if {0x0f & $::teaish__Config(tm-policy)} {
-    file delete -force -- [get-define TEAISH_TM_TCL]
-    proj-dot-ins-append [get-define TEAISH_TM_TCL_IN]
-  }
-
-  apply {{} {
-    # Queue up any remaining dot-in files
-    set dotIns [list]
-    foreach {dIn => dOut} {
-      TEAISH_TESTER_TCL_IN => TEAISH_TESTER_TCL
-      TEAISH_TEST_TCL_IN   => TEAISH_TEST_TCL
-      TEAISH_MAKEFILE_IN   => TEAISH_MAKEFILE
-    } {
-      lappend dotIns [get-define $dIn ""] [get-define $dOut ""]
-    }
-    lappend dotIns $::autosetup(srcdir)/Makefile.in Makefile; # must be after TEAISH_MAKEFILE_IN.
-    # Much later: probably because of timestamps for deps purposes :-?
-    #puts "dotIns=$dotIns"
-    foreach {i o} $dotIns {
-      if {"" ne $i && "" ne $o} {
-        #puts " pre-dot-ins-append:  \[$i\] -> \[$o\]"
-        proj-dot-ins-append $i $o
-      }
-    }
-  }}
-
-  define TEAISH_DIST_FULL \
-    [expr {
-           $::teaish__Config(dist-enabled)
-           && $::teaish__Config(dist-full-enabled)
-         }]
-
-  define TEAISH_AUTOSETUP_DIR  $::teaish__Config(core-dir)
-  define TEAISH_ENABLE_DIST    $::teaish__Config(dist-enabled)
-  define TEAISH_ENABLE_INSTALL $::teaish__Config(install-enabled)
-  define TEAISH_ENABLE_DLL     $::teaish__Config(dll-enabled)
-  define TEAISH_TCL            $::teaish__Config(teaish.tcl)
-
-  define TEAISH_DIST_FILES     [join $::teaish__Config(dist-files)]
-  define TEAISH_EXT_DIR        [join $::teaish__Config(extension-dir)]
-  define TEAISH_EXT_SRC        [join $::teaish__Config(extension-src)]
-  proj-setup-autoreconfig TEAISH_AUTORECONFIG
-  foreach f {
-    TEAISH_CFLAGS
-    TEAISH_LDFLAGS
-  } {
-    # Ensure that any of these lists are flattened
-    define $f [join [get-define $f]]
-  }
-  proj-remap-autoconf-dir-vars
-  set tdefs [teaish__defines_to_list]
-  define TEAISH__DEFINES_MAP $tdefs; # injected into _teaish.tester.tcl
-
-  #
-  # NO [define]s after this point!
-  #
-  proj-if-opt-truthy teaish-dump-defines {
-    proj-file-write config.defines.txt $tdefs
-  }
-  proj-dot-ins-process -validate
-
-}; # teaish__configure_phase1
-
-#
-# Run checks for required binaries.
-#
-proc teaish__check_common_bins {} {
-  if {"" eq [proj-bin-define install]} {
-    proj-warn "Cannot find install binary, so 'make install' will not work."
-    define BIN_INSTALL false
-  }
-  if {"" eq [proj-bin-define zip]} {
-    proj-warn "Cannot find zip, so 'make dist.zip' will not work."
-  }
-  if {"" eq [proj-bin-define tar]} {
-    proj-warn "Cannot find tar, so 'make dist.tgz' will not work."
-  }
-}
-
-#
-# TCL...
-#
-# teaish__check_tcl performs most of the --with-tcl and --with-tclsh
-# handling. Some related bits and pieces are performed before and
-# after that function is called.
-#
-# Important [define]'d vars:
-#
-#  - TCLSH_CMD is the path to the canonical tclsh or "".
-#
-#  - TCL_CONFIG_SH is the path to tclConfig.sh or "".
-#
-#  - TCLLIBDIR is the dir to which the extension library gets
-#  - installed.
-#
-proc teaish__check_tcl {} {
-  define TCLSH_CMD false ; # Significant is that it exits with non-0
-  define TCLLIBDIR ""    ; # Installation dir for TCL extension lib
-  define TCL_CONFIG_SH ""; # full path to tclConfig.sh
-
-  # Clear out all vars which would harvest from tclConfig.sh so that
-  # the late-config validation of @VARS@ works even if --disable-tcl
-  # is used.
-  proj-tclConfig-sh-to-autosetup ""
-
-  # TODO: better document the steps this is taking.
-  set srcdir $::autosetup(srcdir)
-  msg-result "Checking for a suitable tcl... "
-  set use_tcl 1
-  set withSh [opt-val with-tclsh [proj-get-env TCLSH]]
-  set tclHome [opt-val with-tcl [proj-get-env TCL_HOME]]
-  if {[string match */lib $tclHome]} {
-    # TEA compatibility kludge: its --with-tcl wants the lib
-    # dir containing tclConfig.sh.
-    #proj-warn "Replacing --with-tcl=$tclHome for TEA compatibility"
-    regsub {/lib^} $tclHome "" tclHome
-    msg-result "NOTE: stripped /lib suffix from --with-tcl=$tclHome (a TEA-ism)"
-  }
-  if {0} {
-    # This misinteracts with the $TCL_PREFIX default: it will use the
-    # autosetup-defined --prefix default
-    if {"prefix" eq $tclHome} {
-      set tclHome [get-define prefix]
-    }
-  }
-  teaish-debug "use_tcl ${use_tcl}"
-  teaish-debug "withSh=${withSh}"
-  teaish-debug "tclHome=$tclHome"
-  if {"" eq $withSh && "" eq $tclHome} {
-    # If neither --with-tclsh nor --with-tcl are provided, try to find
-    # a workable tclsh.
-    set withSh [proj-first-bin-of tclsh9.1 tclsh9.0 tclsh8.6 tclsh]
-    teaish-debug "withSh=${withSh}"
-  }
-
-  set doConfigLookup 1 ; # set to 0 to test the tclConfig.sh-not-found cases
-  if {"" ne $withSh} {
-    # --with-tclsh was provided or found above. Validate it and use it
-    # to trump any value passed via --with-tcl=DIR.
-    if {![file-isexec $withSh]} {
-      proj-error "TCL shell $withSh is not executable"
-    } else {
-      define TCLSH_CMD $withSh
-      #msg-result "Using tclsh: $withSh"
-    }
-    if {$doConfigLookup &&
-        [catch {exec $withSh $::autosetup(libdir)/find_tclconfig.tcl} result] == 0} {
-      set tclHome $result
-    }
-    if {"" ne $tclHome && [file isdirectory $tclHome]} {
-      teaish__verbose 1 msg-result "$withSh recommends the tclConfig.sh from $tclHome"
-    } else {
-      proj-warn "$withSh is unable to recommend a tclConfig.sh"
-      set use_tcl 0
-    }
-  }
-  set cfg ""
-  set tclSubdirs {tcl9.1 tcl9.0 tcl8.6 tcl8.5 lib}
-  while {$use_tcl} {
-    if {"" ne $tclHome} {
-      # Ensure that we can find tclConfig.sh under ${tclHome}/...
-      if {$doConfigLookup} {
-        if {[file readable "${tclHome}/tclConfig.sh"]} {
-          set cfg "${tclHome}/tclConfig.sh"
-        } else {
-          foreach i $tclSubdirs {
-            if {[file readable "${tclHome}/$i/tclConfig.sh"]} {
-              set cfg "${tclHome}/$i/tclConfig.sh"
-              break
-            }
-          }
-        }
-      }
-      if {"" eq $cfg} {
-        proj-error "No tclConfig.sh found under ${tclHome}"
-      }
-    } else {
-      # If we have not yet found a tclConfig.sh file, look in $libdir
-      # which is set automatically by autosetup or via the --prefix
-      # command-line option.  See
-      # https://sqlite.org/forum/forumpost/e04e693439a22457
-      set libdir [get-define libdir]
-      if {[file readable "${libdir}/tclConfig.sh"]} {
-        set cfg "${libdir}/tclConfig.sh"
-      } else {
-        foreach i $tclSubdirs {
-          if {[file readable "${libdir}/$i/tclConfig.sh"]} {
-            set cfg "${libdir}/$i/tclConfig.sh"
-            break
-          }
-        }
-      }
-      if {![file readable $cfg]} {
-        break
-      }
-    }
-    teaish__verbose 1 msg-result "Using tclConfig.sh = $cfg"
-    break
-  }; # while {$use_tcl}
-  define TCL_CONFIG_SH $cfg
-  # Export a subset of tclConfig.sh to the current TCL-space.  If $cfg
-  # is an empty string, this emits empty-string entries for the
-  # various options we're interested in.
-  proj-tclConfig-sh-to-autosetup $cfg
-
-  if {"" eq $withSh && $cfg ne ""} {
-    # We have tclConfig.sh but no tclsh. Attempt to locate a tclsh
-    # based on info from tclConfig.sh.
-    set tclExecPrefix [get-define TCL_EXEC_PREFIX]
-    proj-assert {"" ne $tclExecPrefix}
-    set tryThese [list \
-                    $tclExecPrefix/bin/tclsh[get-define TCL_VERSION] \
-                    $tclExecPrefix/bin/tclsh ]
-    foreach trySh $tryThese {
-      if {[file-isexec $trySh]} {
-        set withSh $trySh
-        break
-      }
-    }
-    if {![file-isexec $withSh]} {
-      proj-warn "Cannot find a usable tclsh (tried: $tryThese)"
-    }
-  }
-  define TCLSH_CMD $withSh
-  if {$use_tcl} {
-    # Set up the TCLLIBDIR
-    set tcllibdir [get-env TCLLIBDIR ""]
-    set extDirName [teaish-pkginfo-get -libDir]
-    if {"" eq $tcllibdir} {
-      # Attempt to extract TCLLIBDIR from TCL's $auto_path
-      if {"" ne $withSh &&
-          [catch {exec echo "puts stdout \$auto_path" | "$withSh"} result] == 0} {
-        foreach i $result {
-          if {![string match //zip* $i] && [file isdirectory $i]} {
-            # isdirectory actually passes on //zipfs:/..., but those are
-            # useless for our purposes
-            set tcllibdir $i/$extDirName
-            break
-          }
-        }
-      } else {
-        proj-error "Cannot determine TCLLIBDIR."
-      }
-    }
-    define TCLLIBDIR $tcllibdir
-  }; # find TCLLIBDIR
-
-  set gotSh [file-isexec $withSh]
-  set tmdir ""; # first tcl::tm::list entry
-  if {$gotSh} {
-    catch {
-      set tmli [exec echo {puts [tcl::tm::list]} | $withSh]
-      # Reminder: this list contains many names of dirs which do not
-      # exist but are legitimate. If we rely only on an is-dir check,
-      # we can end up not finding any of the many candidates.
-      set firstDir ""
-      foreach d $tmli {
-        if {"" eq $firstDir && ![string match //*:* $d]} {
-          # First non-VFS entry, e.g. not //zipfs:
-          set firstDir $d
-        }
-        if {[file isdirectory $d]} {
-          set tmdir $d
-          break
-        }
-      }
-      if {"" eq $tmdir} {
-        set tmdir $firstDir
-      }
-    }; # find tcl::tm path
-  }
-  define TEAISH_TCL_TM_DIR $tmdir
-
-  # Finally, let's wrap up...
-  if {$gotSh} {
-    teaish__verbose 1 msg-result "Using tclsh        = $withSh"
-    if {$cfg ne ""} {
-      define HAVE_TCL 1
-    } else {
-      proj-warn "Found tclsh but no tclConfig.sh."
-    }
-    if {"" eq $tmdir} {
-      proj-warn "Did not find tcl::tm directory."
-    }
-  }
-  show-notices
-  # If TCL is not found: if it was explicitly requested then fail
-  # fatally, else just emit a warning. If we can find the APIs needed
-  # to generate a working JimTCL then that will suffice for build-time
-  # TCL purposes (see: proc sqlite-determine-codegen-tcl).
-  if {!$gotSh} {
-    proj-error "Did not find tclsh"
-  } elseif {"" eq $cfg} {
-    proj-indented-notice -error {
-      Cannot find a usable tclConfig.sh file.  Use --with-tcl=DIR to
-      specify a directory near which tclConfig.sh can be found, or
-      --with-tclsh=/path/to/tclsh to allow the tclsh binary to locate
-      its tclConfig.sh, with the caveat that a symlink to tclsh, or
-      wrapper script around it, e.g. ~/bin/tclsh ->
-      $HOME/tcl/9.0/bin/tclsh9.1, may not work because tclsh emits
-      different library paths for the former than the latter.
-    }
-  }
-  msg-result "Using Tcl [get-define TCL_VERSION] from [get-define TCL_PREFIX]."
-  teaish__tcl_platform_quirks
-}; # teaish__check_tcl
-
-#
-# Perform last-minute platform-specific tweaks to account for quirks.
-#
-proc teaish__tcl_platform_quirks {} {
-  define TEAISH_POSTINST_PREREQUIRE ""
-  switch -glob -- [get-define host] {
-    *-haiku {
-      # Haiku's default TCLLIBDIR is "all wrong": it points to a
-      # read-only virtual filesystem mount-point. We bend it back to
-      # fit under $TCL_PACKAGE_PATH here.
-      foreach {k d} {
-        vj TCL_MAJOR_VERSION
-        vn TCL_MINOR_VERSION
-        pp TCL_PACKAGE_PATH
-        ld TCLLIBDIR
-      } {
-        set $k [get-define $d]
-      }
-      if {[string match /packages/* $ld]} {
-        set old $ld
-        set tail [file tail $ld]
-        if {8 == $vj} {
-          set ld "${pp}/tcl${vj}.${vn}/${tail}"
-        } else {
-          proj-assert {9 == $vj}
-          set ld "${pp}/${tail}"
-        }
-        define TCLLIBDIR $ld
-        # [load foo.so], without a directory part, does not work via
-        # automated tests on Haiku (but works when run
-        # manually). Similarly, the post-install [package require ...]
-        # test fails, presumably for a similar reason. We work around
-        # the former in _teaish.tester.tcl.in. We work around the
-        # latter by amending the post-install check's ::auto_path (in
-        # Makefile.in). This code MUST NOT contain any single-quotes.
-        define TEAISH_POSTINST_PREREQUIRE \
-          [join [list set ::auto_path \
-                   \[ linsert \$::auto_path 0 $ld \] \; \
-                  ]]
-        proj-indented-notice [subst -nocommands -nobackslashes {
-          Haiku users take note: patching target installation dir to match
-          Tcl's home because Haiku's is not writable.
-
-          Original  : $old
-          Substitute: $ld
-        }]
-      }
-    }
-  }
-}; # teaish__tcl_platform_quirks
-
-#
-# Searches $::argv and/or the build dir and/or the source dir for
-# teaish.tcl and friends. Fails if it cannot find teaish.tcl or if
-# there are other irreconcilable problems. If it returns 0 then it did
-# not find an extension but the --help flag was seen, in which case
-# that's not an error.
-#
-# This does not _load_ the extension, it primarily locates the files
-# which make up an extension and fills out no small amount of teaish
-# state related to that.
-#
-proc teaish__find_extension {} {
-  proj-assert {!$::teaish__Config(install-mode)}
-  teaish__verbose 1 msg-result "Looking for teaish extension..."
-
-  # Helper for the foreach loop below.
-  set checkTeaishTcl {{mustHave fid dir} {
-    set f [file join $dir $fid]
-    if {[file readable $f]} {
-      file-normalize $f
-    } elseif {$mustHave} {
-      proj-error "Missing required $dir/$fid"
-    }
-  }}
-
-  #
-  # We have to handle some flags manually because the extension must
-  # be loaded before [options] is run (so that the extension can
-  # inject its own options).
-  #
-  set dirBld $::autosetup(builddir); # dir we're configuring under
-  set dirSrc $::autosetup(srcdir);   # where teaish's configure script lives
-  set extT ""; # teaish.tcl
-  set largv {}; # rewritten $::argv
-  set gotHelpArg 0; # got the --help
-  foreach arg $::argv {
-    #puts "*** arg=$arg"
-    switch -glob -- $arg {
-      --ted=* -
-      --t-e-d=* -
-      --teaish-extension-dir=* {
-        # Ensure that $extD refers to a directory and contains a
-        # teaish.tcl.
-        regexp -- {--[^=]+=(.+)} $arg - extD
-        set extD [file-normalize $extD]
-        if {![file isdirectory $extD]} {
-          proj-error "--teaish-extension-dir value is not a directory: $extD"
-        }
-        set extT [apply $checkTeaishTcl 0 teaish.config $extD]
-        if {"" eq $extT} {
-          set extT [apply $checkTeaishTcl 1 teaish.tcl $extD]
-        }
-        set ::teaish__Config(extension-dir) $extD
-      }
-      --help {
-        incr gotHelpArg
-        lappend largv $arg
-      }
-      default {
-        lappend largv $arg
-      }
-    }
-  }
-  set ::argv $largv
-
-  set dirExt $::teaish__Config(extension-dir); # dir with the extension
-  #
-  # teaish.tcl is a TCL script which implements various
-  # interfaces described by this framework.
-  #
-  # We use the first one we find in the builddir or srcdir.
-  #
-  if {"" eq $extT} {
-    set flist [list]
-    proj-assert {$dirExt eq ""}
-    lappend flist $dirBld/teaish.tcl $dirBld/teaish.config $dirSrc/teaish.tcl
-    if {![proj-first-file-found extT $flist]} {
-      if {$gotHelpArg} {
-        # Tell teaish-configure-core that the lack of extension is not
-        # an error when --help or --teaish-install is used.
-        return 0;
-      }
-      proj-indented-notice -error "
-Did not find any of: $flist
-
-If you are attempting an out-of-tree build, use
- --teaish-extension-dir=/path/to/extension"
-    }
-  }
-  if {![file readable $extT]} {
-    proj-error "extension tcl file is not readable: $extT"
-  }
-  set ::teaish__Config(teaish.tcl) $extT
-  set dirExt [file dirname $extT]
-
-  set ::teaish__Config(extension-dir) $dirExt
-  set ::teaish__Config(blddir-is-extdir) [expr {$dirBld eq $dirExt}]
-  set ::teaish__Config(dist-enabled) $::teaish__Config(blddir-is-extdir); # may change later
-  set ::teaish__Config(dist-full-enabled) \
-    [expr {[file-normalize $::autosetup(srcdir)]
-           eq [file-normalize $::teaish__Config(extension-dir)]}]
-
-  set addDist {{file} {
-    teaish-dist-add [file tail $file]
-  }}
-  apply $addDist $extT
-
-  teaish__verbose 1 msg-result "Extension dir            = [teaish-get -dir]"
-  teaish__verbose 1 msg-result "Extension config         = $extT"
-
-  teaish-pkginfo-set -name [file tail [file dirname $extT]]
-
-  #
-  # teaish.make[.in] provides some of the info for the main makefile,
-  # like which source(s) to build and their build flags.
-  #
-  # We use the first one of teaish.make.in or teaish.make we find in
-  # $dirExt.
-  #
-  if {[proj-first-file-found extM \
-         [list \
-            $dirExt/teaish.make.in \
-            $dirExt/teaish.make \
-         ]]} {
-    if {[string match *.in $extM]} {
-      define TEAISH_MAKEFILE_IN $extM
-      define TEAISH_MAKEFILE _[file rootname [file tail $extM]]
-    } else {
-      define TEAISH_MAKEFILE_IN ""
-      define TEAISH_MAKEFILE $extM
-    }
-    apply $addDist $extM
-    teaish__verbose 1 msg-result "Extension makefile       = $extM"
-  } else {
-    define TEAISH_MAKEFILE_IN ""
-    define TEAISH_MAKEFILE ""
-  }
-
-  # Look for teaish.pkginit.tcl[.in]
-  set piPolicy 0
-  if {[proj-first-file-found extI \
-         [list \
-            $dirExt/teaish.pkginit.tcl.in \
-            $dirExt/teaish.pkginit.tcl \
-           ]]} {
-    if {[string match *.in $extI]} {
-      # Generate teaish.pkginit.tcl from $extI.
-      define TEAISH_PKGINIT_TCL_IN $extI
-      define TEAISH_PKGINIT_TCL [file rootname [file tail $extI]]
-      set piPolicy 0x01
-    } else {
-      # Assume static $extI.
-      define TEAISH_PKGINIT_TCL_IN ""
-      define TEAISH_PKGINIT_TCL $extI
-      set piPolicy 0x10
-    }
-    apply $addDist $extI
-    teaish__verbose 1 msg-result "Extension post-load init = $extI"
-    define TEAISH_PKGINIT_TCL_TAIL \
-      [file tail [get-define TEAISH_PKGINIT_TCL]]; # for use in pkgIndex.tcl.in
-  }
-  set ::teaish__Config(pkginit-policy) $piPolicy
-
-  # Look for pkgIndex.tcl[.in]...
-  set piPolicy 0
-  if {[proj-first-file-found extPI $dirExt/pkgIndex.tcl.in]} {
-    # Generate ./pkgIndex.tcl from $extPI.
-    define TEAISH_PKGINDEX_TCL_IN $extPI
-    define TEAISH_PKGINDEX_TCL [file rootname [file tail $extPI]]
-    apply $addDist $extPI
-    set piPolicy 0x01
-  } elseif {$dirExt ne $dirSrc
-            && [proj-first-file-found extPI $dirSrc/pkgIndex.tcl.in]} {
-    # Generate ./pkgIndex.tcl from $extPI.
-    define TEAISH_PKGINDEX_TCL_IN $extPI
-    define TEAISH_PKGINDEX_TCL [file rootname [file tail $extPI]]
-    set piPolicy 0x02
-  } elseif {[proj-first-file-found extPI $dirExt/pkgIndex.tcl]} {
-    # Assume $extPI's a static file and use it.
-    define TEAISH_PKGINDEX_TCL_IN ""
-    define TEAISH_PKGINDEX_TCL $extPI
-    apply $addDist $extPI
-    set piPolicy 0x10
-  }
-  # Reminder: we have to delay removal of stale TEAISH_PKGINDEX_TCL
-  # and the proj-dot-ins-append of TEAISH_PKGINDEX_TCL_IN until much
-  # later in the process.
-  set ::teaish__Config(pkgindex-policy) $piPolicy
-
-  # Look for teaish.test.tcl[.in]
-  proj-assert {"" ne $dirExt}
-  set flist [list $dirExt/teaish.test.tcl.in $dirExt/teaish.test.tcl]
-  if {[proj-first-file-found ttt $flist]} {
-    if {[string match *.in $ttt]} {
-      # Generate _teaish.test.tcl from $ttt
-      set xt _[file rootname [file tail $ttt]]
-      file delete -force -- $xt; # ensure no stale copy is used
-      define TEAISH_TEST_TCL $xt
-      define TEAISH_TEST_TCL_IN $ttt
-    } else {
-      define TEAISH_TEST_TCL $ttt
-      define TEAISH_TEST_TCL_IN ""
-    }
-    apply $addDist $ttt
-  } else {
-    define TEAISH_TEST_TCL ""
-    define TEAISH_TEST_TCL_IN ""
-  }
-
-  # Look for _teaish.tester.tcl[.in]
-  set flist [list $dirExt/_teaish.tester.tcl.in $dirSrc/_teaish.tester.tcl.in]
-  if {[proj-first-file-found ttt $flist]} {
-    # Generate teaish.test.tcl from $ttt
-    set xt [file rootname [file tail $ttt]]
-    file delete -force -- $xt; # ensure no stale copy is used
-    define TEAISH_TESTER_TCL $xt
-    define TEAISH_TESTER_TCL_IN $ttt
-    if {[lindex $flist 0] eq $ttt} {
-      apply $addDist $ttt
-    }
-    unset ttt xt
-  } else {
-    if {[file exists [set ttt [file join $dirSrc _teaish.tester.tcl.in]]]} {
-      set xt [file rootname [file tail $ttt]]
-      define TEAISH_TESTER_TCL $xt
-      define TEAISH_TESTER_TCL_IN $ttt
-    } else {
-      define TEAISH_TESTER_TCL ""
-      define TEAISH_TESTER_TCL_IN ""
-    }
-  }
-  unset flist
-
-  # TEAISH_OUT_OF_EXT_TREE = 1 if we're building from a dir other
-  # than the extension's home dir.
-  define TEAISH_OUT_OF_EXT_TREE \
-    [expr {[file-normalize $::autosetup(builddir)] ne \
-             [file-normalize $::teaish__Config(extension-dir)]}]
-  return 1
-}; # teaish__find_extension
-
-#
-# @teaish-cflags-add ?-p|prepend? ?-define? cflags...
-#
-# Equivalent to [proj-define-amend TEAISH_CFLAGS {*}$args].
-#
-proc teaish-cflags-add {args} {
-  proj-define-amend TEAISH_CFLAGS {*}$args
-}
-
-#
-# @teaish-define-to-cflag ?flags? defineName...|{defineName...}
-#
-# Uses [proj-define-to-cflag] to expand a list of [define] keys, each
-# one a separate argument, to CFLAGS-style -D... form then appends
-# that to the current TEAISH_CFLAGS.
-#
-# It accepts these flags from proj-define-to-cflag: -quote,
-# -zero-undef. It does _not_ support its -list flag.
-#
-# It accepts its non-flag argument(s) in 2 forms: (1) each arg is a
-# single [define] key or (2) its one arg is a list of such keys.
-#
-# TODO: document teaish's well-defined (as it were) defines for this
-# purpose. At a bare minimum:
-#
-#  - TEAISH_NAME
-#  - TEAISH_PKGNAME
-#  - TEAISH_VERSION
-#  - TEAISH_LIBDIR_NAME
-#  - TEAISH_LOAD_PREFIX
-#  - TEAISH_URL
-#
-proc teaish-define-to-cflag {args} {
-  set flags {}
-  while {[string match -* [lindex $args 0]]} {
-    set arg [lindex $args 0]
-    switch -exact -- $arg {
-      -quote -
-      -zero-undef {
-        lappend flags $arg
-        set args [lassign $args -]
-      }
-      default break
-    }
-  }
-  if {1 == [llength $args]} {
-    set args [list {*}[lindex $args 0]]
-  }
-  #puts "***** flags=$flags args=$args"
-  teaish-cflags-add [proj-define-to-cflag {*}$flags {*}$args]
-}
-
-#
-# @teaish-cflags-for-tea ?...CFLAGS?
-#
-# Adds several -DPACKAGE_... CFLAGS using the extension's metadata,
-# all as quoted strings. Those symbolic names are commonly used in
-# TEA-based builds, and this function is intended to simplify porting
-# of such builds. The -D... flags added are:
-#
-#  -DPACKAGE_VERSION=...
-#  -DPACKAGE_NAME=...
-#  -DPACKAGE_URL=...
-#  -DPACKAGE_STRING=...
-#
-# Any arguments are passed-on as-is to teaish-cflags-add.
-#
-proc teaish-cflags-for-tea {args} {
-  set name $::teaish__PkgInfo(-name)
-  set version $::teaish__PkgInfo(-version)
-  set pstr [join [list $name $version]]
-  teaish-cflags-add \
-    {*}$args \
-    '-DPACKAGE_VERSION="$version"' \
-    '-DPACKAGE_NAME="$name"' \
-    '-DPACKAGE_STRING="$pstr"' \
-    '-DPACKAGE_URL="[teaish-get -url]"'
-}
-
-#
-# @teaish-ldflags-add ?-p|-prepend? ?-define? ldflags...
-#
-# Equivalent to [proj-define-amend TEAISH_LDFLAGS {*}$args].
-#
-# Typically, -lXYZ flags need to be in "reverse" order, with each -lY
-# resolving symbols for -lX's to its left. This order is largely
-# historical, and not relevant on all environments, but it is
-# technically correct and still relevant on some environments.
-#
-# See: teaish-ldflags-prepend
-#
-proc teaish-ldflags-add {args} {
-  proj-define-amend TEAISH_LDFLAGS {*}$args
-}
-
-#
-# @teaish-ldflags-prepend args...
-#
-# Functionally equivalent to [teaish-ldflags-add -p {*}$args]
-#
-proc teaish-ldflags-prepend {args} {
-  teaish-ldflags-add -p {*}$args
-}
-
-#
-# @teaish-src-add ?-dist? ?-dir? src-files...
-#
-# Appends all non-empty $args to the project's list of C/C++ source or
-# (in some cases) object files.
-#
-# If passed -dist then it also passes each filename, as-is, to
-# [teaish-dist-add].
-#
-# If passed -dir then each src-file has [teaish-get -dir] prepended to
-# it before they're added to the list. As often as not, that will be
-# the desired behavior so that out-of-tree builds can find the
-# sources, but there are cases where it's not desired (e.g. when using
-# a source file from outside of the extension's dir, or when adding
-# object files (which are typically in the build tree)).
-#
-proc teaish-src-add {args} {
-  proj-parse-simple-flags args flags {
-    -dist 0 {expr 1}
-    -dir  0 {expr 1}
-  }
-  if {$flags(-dist)} {
-    teaish-dist-add {*}$args
-  }
-  if {$flags(-dir)} {
-    set xargs {}
-    foreach arg $args {
-      if {"" ne $arg} {
-        lappend xargs [file join $::teaish__Config(extension-dir) $arg]
-      }
-    }
-    set args $xargs
-  }
-  lappend ::teaish__Config(extension-src) {*}$args
-}
-
-#
-# @teaish-dist-add files-or-dirs...
-#
-# Adds the given files to the list of files to include with the "make
-# dist" rules.
-#
-# This is a no-op when the current build is not in the extension's
-# directory, as dist support is disabled in out-of-tree builds.
-#
-# It is not legal to call this until [teaish-get -dir] has been
-# reliably set (via teaish__find_extension).
-#
-proc teaish-dist-add {args} {
-  if {$::teaish__Config(blddir-is-extdir)} {
-    # ^^^ reminder: we ignore $::teaish__Config(dist-enabled) here
-    # because the client might want to implement their own dist
-    # rules.
-    #proj-warn "**** args=$args"
-    lappend ::teaish__Config(dist-files) {*}$args
-  }
-}
-
-# teaish-install-add files...
-# Equivalent to [proj-define-apend TEAISH_INSTALL_FILES ...].
-#proc teaish-install-add {args} {
-#  proj-define-amend TEAISH_INSTALL_FILES {*}$args
-#}
-
-#
-# @teash-make-add args...
-#
-# Appends makefile code to the TEAISH_MAKEFILE_CODE define. Each
-# arg may be any of:
-#
-# -tab: emit a literal tab
-# -nl: emit a literal newline
-# -nltab: short for -nl -tab
-# -bnl: emit a backslash-escaped end-of-line
-# -bnltab: short for -eol -tab
-#
-# Anything else is appended verbatim. This function adds no additional
-# spacing between each argument nor between subsequent invocations.
-# Generally speaking, a series of calls to this function need to
-# be sure to end the series with a newline.
-proc teaish-make-add {args} {
-  set out [get-define TEAISH_MAKEFILE_CODE ""]
-  foreach a $args {
-    switch -exact -- $a {
-      -bnl    { set a " \\\n" }
-      -bnltab { set a " \\\n\t" }
-      -tab    { set a "\t" }
-      -nl     { set a "\n" }
-      -nltab  { set a "\n\t" }
-    }
-    append out $a
-  }
-  define TEAISH_MAKEFILE_CODE $out
-}
-
-# Internal helper to generate a clean/distclean rule name
-proc teaish__cleanup_rule {{tgt clean}} {
-  set x [incr ::teaish__Config(teaish__cleanup_rule-counter-${tgt})]
-  return ${tgt}-_${x}_
-}
-
-# @teaish-make-obj ?flags? ?...args?
-#
-# Uses teaish-make-add to inject makefile rules for $objfile from
-# $srcfile, which is assumed to be C code which uses libtcl. Unless
-# -recipe is used (see below) it invokes the compiler using the
-# makefile-defined $(CC.tcl) which, in the default Makefile.in
-# template, includes any flags needed for building against the
-# configured Tcl.
-#
-# This always terminates the resulting code with a newline.
-#
-# Any arguments after the 2nd may be flags described below or, if no
-# -recipe is provided, flags for the compiler call.
-#
-#   -obj obj-filename.o
-#
-#   -src src-filename.c
-#
-#   -recipe {...}
-#   Uses the trimmed value of {...} as the recipe, prefixing it with
-#   a single hard-tab character.
-#
-#   -deps {...}
-#   List of extra files to list as dependencies of $o.
-#
-#   -clean
-#   Generate cleanup rules as well.
-proc teaish-make-obj {args} {
-  proj-parse-simple-flags args flags {
-    -clean 0 {expr 1}
-    -recipe => {}
-    -deps => {}
-    -obj => {}
-    -src => {}
-  }
-  #parray flags
-  if {"" eq $flags(-obj)} {
-    set args [lassign $args flags(-obj)]
-    if {"" eq $flags(-obj)} {
-      proj-error "Missing -obj flag."
-    }
-  }
-  foreach f {-deps -src} {
-    set flags($f) [string trim [string map {\n " "} $flags($f)]]
-  }
-  foreach f {-deps -src} {
-    set flags($f) [string trim $flags($f)]
-  }
-  #parray flags
-  #puts "-- args=$args"
-  teaish-make-add \
-    "# [proj-scope 1] -> [proj-scope] $flags(-obj) $flags(-src)" -nl \
-    "$flags(-obj): $flags(-src) $::teaish__Config(teaish.tcl)"
-  if {[info exists flags(-deps)]} {
-    teaish-make-add " " [join $flags(-deps)]
-  }
-  teaish-make-add -nltab
-  if {[info exists flags(-recipe)]} {
-    teaish-make-add [string trim $flags(-recipe)] -nl
-  } else {
-    teaish-make-add [join [list \$(CC.tcl) -c $flags(-src) {*}$args]] -nl
-  }
-  if {$flags(-clean)} {
-    set rule [teaish__cleanup_rule]
-    teaish-make-add \
-      "clean: $rule\n$rule:\n\trm -f \"$flags(-obj)\"\n"
-  }
-}
-
-#
-# @teaish-make-clean ?-r? ?-dist? ...files|{...files}
-#
-# Adds makefile rules for cleaning up the given files via the "make
-# clean" or (if -dist is used) "make distclean" makefile rules. The -r
-# flag uses "rm -fr" instead of "rm -f", so be careful with that.
-#
-# The file names are taken literally as arguments to "rm", so they may
-# be shell wildcards to be resolved at cleanup-time. To clean up whole
-# directories, pass the -r flag. Each name gets quoted in
-# double-quotes, so spaces in names should not be a problem (but
-# double-quotes in names will be).
-#
-proc teaish-make-clean {args} {
-  if {1 == [llength $args]} {
-    set args [list {*}[lindex $args 0]]
-  }
-
-  set tgt clean
-  set rmflags "-f"
-  proj-parse-simple-flags args flags {
-    -dist 0 {
-      set tgt distclean
-    }
-    -r 0 {
-      set rmflags "-fr"
-    }
-  }
-  set rule [teaish__cleanup_rule $tgt]
-  teaish-make-add "# [proj-scope 1] -> [proj-scope]: [join $args]\n"
-  teaish-make-add "${rule}:\n\trm ${rmflags}"
-  foreach a $args {
-    teaish-make-add " \"$a\""
-  }
-  teaish-make-add "\n${tgt}: ${rule}\n"
-}
-
-#
-# @teaish-make-config-header filename
-#
-# Invokes autosetup's [make-config-header] and passes it $filename and
-# a relatively generic list of options for controlling which defined
-# symbols get exported. Clients which need more control over the
-# exports can copy/paste/customize this.
-#
-# The exported file is then passed to [proj-touch] because, in
-# practice, that's sometimes necessary to avoid build dependency
-# issues.
-#
-proc teaish-make-config-header {filename} {
-  make-config-header $filename \
-    -none {HAVE_CFLAG_* LDFLAGS_* SH_* TEAISH__* TEAISH_*_CODE} \
-    -auto {SIZEOF_* HAVE_* TEAISH_*  TCL_*} \
-    -none *
-  proj-touch $filename; # help avoid frequent unnecessary auto-reconfig
-}
-
-#
-# @teaish-feature-cache-set $key value
-#
-# Sets a feature-check cache entry with the given key.
-# See proj-cache-set for the key's semantics. $key should
-# normally be 0.
-#
-proc teaish-feature-cache-set {key val} {
-  proj-cache-set -key $key -level 1 $val
-}
-
-#
-# @teaish-feature-cache-check key tgtVarName
-#
-# Checks for a feature-check cache entry with the given key.
-# See proj-cache-set for the key's semantics.
-#
-# $key should also almost always be 0 but, due to a tclsh
-# incompatibility in 1 OS, it cannot have a default value unless it's
-# the second argument (but it should be the first one).
-#
-# If the feature-check cache has a matching entry then this function
-# assigns its value to tgtVar and returns 1, else it assigns tgtVar to
-# "" and returns 0.
-#
-# See proj-cache-check for $key's semantics.
-#
-proc teaish-feature-cache-check {key tgtVar} {
-  upvar $tgtVar tgt
-  proj-cache-check -key $key -level 1 tgt
-}
-
-#
-# @teaish-check-cached@ ?flags? msg script...
-#
-# A proxy for feature-test impls which handles caching of a feature
-# flag check on per-function basis, using the calling scope's name as
-# the cache key.
-#
-# It emits [msg-checking $msg]. If $msg is empty then it defaults to
-# the name of the caller's scope. The -nomsg flag suppresses the
-# message for non-cache-hit checks. At the end, it will [msg-result
-# "ok"] [msg-result "no"] unless -nostatus is used, in which case the
-# caller is responsible for emitting at least a newline when it's
-# done. The -msg-0 and -msg-1 flags can be used to change the ok/no
-# text.
-#
-# This function checks for a cache hit before running $script and
-# caching the result. If no hit is found then $script is run in the
-# calling scope and its result value is stored in the cache. This
-# routine will intercept a 'return' from $script.
-#
-# $script may be a command and its arguments, as opposed to a single
-# script block.
-#
-# Flags:
-#
-#   -nostatus = do not emit "ok" or "no" at the end. This presumes
-#    that either $script will emit at least one newline before
-#    returning or the caller will account for it. Because of how this
-#    function is typically used, -nostatus is not honored when the
-#    response includes a cached result.
-#
-#   -quiet = disable output from Autosetup's msg-checking and
-#    msg-result for the duration of the $script check. Note that when
-#    -quiet is in effect, Autosetup's user-notice can be used to queue
-#    up output to appear after the check is done. Also note that
-#    -quiet has no effect on _this_ function, only the $script part.
-#
-#   -nomsg = do not emit $msg for initial check. Like -nostatus, this
-#    flag is not honored when the response includes a cached result
-#    because it would otherwise produce no output (which is confusing
-#    in this context). This is useful when a check runs several other
-#    verbose checks and they emit all the necessary info.
-#
-#   -msg-0 and -msg-1 MSG = strings to show when the check has failed
-#    resp. passed. Defaults are "no" and "ok". The 0 and 1 refer to the
-#    result value from teaish-feature-cache-check.
-#
-#   -key cachekey = set the cache context key. Only needs to be
-#    explicit when using this function multiple times from a single
-#    scope. See proj-cache-check and friends for details on the key
-#    name. Its default is the name of the scope which calls this
-#    function.
-#
-proc teaish-check-cached {args} {
-  proj-parse-simple-flags args flags {
-    -nostatus 0 {expr 1}
-    -quiet    0 {expr 1}
-    -key      => 1
-    -nomsg    0 {expr 1}
-    -msg-0    => no
-    -msg-1    => ok
-  }
-  set args [lassign $args msg]
-  set script [join $args]
-  if {"" eq $msg} {
-    set msg [proj-scope 1]
-  }
-  if {[teaish-feature-cache-check $flags(-key) check]} {
-    #if {0 == $flags(-nomsg)} {
-    msg-checking "${msg} ... (cached) "
-    #}
-    #if {!$flags(-nostatus)} {
-    msg-result $flags(-msg-[expr {0 != ${check}}])
-    #}
-    return $check
-  } else {
-    if {0 == $flags(-nomsg)} {
-      msg-checking "${msg} ... "
-    }
-    if {$flags(-quiet)} {
-      incr ::autosetup(msg-quiet)
-    }
-    set code [catch {uplevel 1 $script} rc xopt]
-    if {$flags(-quiet)} {
-      incr ::autosetup(msg-quiet) -1
-    }
-    #puts "***** cached-check got code=$code rc=$rc"
-    if {$code in {0 2}} {
-      teaish-feature-cache-set 1 $rc
-      if {!$flags(-nostatus)} {
-        msg-result $flags(-msg-[expr {0 != ${rc}}])
-      } else {
-        #show-notices; # causes a phantom newline because we're in a
-        #msg-checking scope, so...
-        if {[info exists ::autosetup(notices)]} {
-          show-notices
-        }
-      }
-    } else {
-      #puts "**** code=$code rc=$rc xopt=$xopt"
-      teaish-feature-cache-set 1 0
-    }
-    #puts "**** code=$code rc=$rc"
-    return {*}$xopt $rc
-  }
-}
-
-#
-# Internal helper for teaish__defs_format_: returns a JSON-ish quoted
-# form of the given string-type values.
-#
-# If $asList is true then the return value is in {$value} form.  If
-# $asList is false it only performs the most basic of escaping and
-# the input must not contain any control characters.
-#
-proc teaish__quote_str {asList value} {
-  if {$asList} {
-    return "{${value}}"
-  }
-  return \"[string map [list \\ \\\\ \" \\\"] $value]\"
-}
-
-#
-# Internal helper for teaish__defines_to_list. Expects to be passed
-# a name and the variadic $args which are passed to
-# teaish__defines_to_list.. If it finds a pattern match for the
-# given $name in the various $args, it returns the type flag for that
-# $name, e.g. "-str" or "-bare", else returns an empty string.
-#
-proc teaish__defs_type {name spec} {
-  foreach {type patterns} $spec {
-    foreach pattern $patterns {
-      if {[string match $pattern $name]} {
-        return $type
-      }
-    }
-  }
-  return ""
-}
-
-#
-# An internal impl detail. Requires a data type specifier, as used by
-# Autosetup's [make-config-header], and a value. Returns the formatted
-# value or the value $::teaish__Config(defs-skip) if the caller should
-# skip emitting that value.
-#
-# In addition to -str, -auto, etc., as defined by make-config-header,
-# it supports:
-#
-#  -list {...} will cause non-integer values to be quoted in {...}
-#  instead of quotes.
-#
-#  -autolist {...} works like -auto {...} except that it falls back to
-#   -list {...} type instead of -str {...} style for non-integers.
-#
-#  -jsarray {...} emits the output in something which, for
-#   conservative inputs, will be a valid JSON array. It can only
-#   handle relatively simple values with no control characters in
-#   them.
-#
-set teaish__Config(defs-skip) "-teaish__defs_format sentinel"
-proc teaish__defs_format {type value} {
-  switch -exact -- $type {
-    -bare {
-      # Just output the value unchanged
-    }
-    -none {
-      set value $::teaish__Config(defs-skip)
-    }
-    -str {
-      set value [teaish__quote_str 0 $value]
-    }
-    -auto {
-      # Automatically determine the type
-      if {![string is integer -strict $value]} {
-        set value [teaish__quote_str 0 $value]
-      }
-    }
-    -autolist {
-      if {![string is integer -strict $value]} {
-        set value [teaish__quote_str 1 $value]
-      }
-    }
-    -list {
-      set value [teaish__quote_str 1 $value]
-    }
-    -jsarray {
-      set ar {}
-      foreach v $value {
-        if {![string is integer -strict $v]} {
-          set v [teaish__quote_str 0 $v]
-        }
-        if {$::teaish__Config(defs-skip) ne $v} {
-          lappend ar $v
-        }
-      }
-      set value [concat \[ [join $ar {, }] \]]
-    }
-    "" {
-      # (Much later:) Why do we do this?
-      set value $::teaish__Config(defs-skip)
-    }
-    default {
-      proj-error \
-        "Unknown [proj-scope] -type ($type) called from" \
-        [proj-scope 1]
-    }
-  }
-  return $value
-}
-
-#
-# Returns Tcl code in the form of code which evaluates to a list of
-# configure-time DEFINEs in the form {key val key2 val...}. It may
-# misbehave for values which are not numeric or simple strings.  Some
-# defines are specifically filtered out of the result, either because
-# their irrelevant to teaish or because they may be arbitrarily large
-# (e.g. makefile content).
-#
-# The $args are explained in the docs for internal-use-only
-# [teaish__defs_format]. The default mode is -autolist.
-#
-proc teaish__defines_to_list {args} {
-  set lines {}
-  lappend lines "\{"
-  set skipper $::teaish__Config(defs-skip)
-  set args [list \
-              -none {
-                TEAISH__*
-                TEAISH_*_CODE
-                AM_* AS_*
-              } \
-              {*}$args \
-              -autolist *]
-  foreach d [lsort [dict keys [all-defines]]] {
-    set type [teaish__defs_type $d $args]
-    set value [teaish__defs_format $type [get-define $d]]
-    if {$skipper ne $value} {
-      lappend lines "$d $value"
-    }
-  }
-  lappend lines "\}"
-  tailcall join $lines "\n"
-}
-
-#
-# teaish__pragma ...flags
-#
-# Offers a way to tweak how teaish's core behaves in some cases, in
-# particular those which require changing how the core looks for an
-# extension and its files.
-#
-# Accepts the following flags. Those marked with [L] are safe to use
-# during initial loading of tclish.tcl (recall that most teaish APIs
-# cannot be used until [teaish-configure] is called).
-#
-#    static-pkgIndex.tcl [L]: Tells teaish that ./pkgIndex.tcl is not
-#    a generated file, so it will not try to overwrite or delete
-#    it. Errors out if it does not find pkgIndex.tcl in the
-#    extension's dir.
-#
-#    no-dist [L]: tells teaish to elide the 'make dist' recipe
-#    from the generated Makefile.
-#
-#    no-dll [L]: tells teaish to elide the DLL-building recipe
-#    from the generated Makefile.
-#
-#    no-vsatisfies-error [L]: tells teaish that failure to match the
-#    -vsatisfies value should simply "return" instead of "error".
-#
-#    no-tester [L]: disables automatic generation of teaish.test.tcl
-#    even if a copy of _teaish.tester.tcl.in is found.
-#
-#    no-full-dist [L]: changes the "make dist" rules to never include
-#    a copy of teaish itself. By default it will include itself only
-#    if the extension lives in the same directory as teaish.
-#
-#    full-dist [L]: changes the "make dist" rules to always include
-#    a copy of teaish itself.
-#
-# Emits a warning message for unknown arguments.
-#
-proc teaish__pragma {args} {
-  foreach arg $args {
-    switch -exact -- $arg {
-
-      static-pkgIndex.tcl {
-        if {$::teaish__Config(tm-policy)} {
-          proj-fatal -up "Cannot use pragma $arg together with -tm.tcl or -tm.tcl.in."
-        }
-        set tpi [file join $::teaish__Config(extension-dir) pkgIndex.tcl]
-        if {[file exists $tpi]} {
-          define TEAISH_PKGINDEX_TCL_IN ""
-          define TEAISH_PKGINDEX_TCL $tpi
-          set ::teaish__Config(pkgindex-policy) 0x20
-        } else {
-          proj-error "pragma $arg: found no package-local pkgIndex.tcl\[.in]"
-        }
-      }
-
-      no-dist {
-        set ::teaish__Config(dist-enabled) 0
-      }
-
-      no-install {
-        set ::teaish__Config(install-enabled) 0
-      }
-
-      full-dist {
-        set ::teaish__Config(dist-full-enabled) 1
-      }
-
-      no-full-dist {
-        set ::teaish__Config(dist-full-enabled) 0
-      }
-
-      no-dll {
-        set ::teaish__Config(dll-enabled) 0
-      }
-
-      no-vsatisfies-error {
-        set ::teaish__Config(vsatisfies-error) 0
-      }
-
-      no-tester {
-        define TEAISH_TESTER_TCL_IN ""
-        define TEAISH_TESTER_TCL ""
-      }
-
-      default {
-        proj-error "Unknown flag: $arg"
-      }
-    }
-  }
-}
-
-#
-# @teaish-pkginfo-set ...flags
-#
-# The way to set up the initial package state. Used like:
-#
-#   teaish-pkginfo-set -name foo -version 0.1.2
-#
-# Or:
-#
-#   teaish-pkginfo-set ?-vars|-subst? {-name foo -version 0.1.2}
-#
-# The latter may be easier to write for a multi-line invocation.
-#
-# For the second call form, passing the -vars flag tells it to perform
-# a [subst] of (only) variables in the {...} part from the calling
-# scope. The -subst flag will cause it to [subst] the {...} with
-# command substitution as well (but no backslash substitution). When
-# using -subst for string concatenation, e.g.  with -libDir
-# foo[get-version-number], be sure to wrap the value in braces:
-# -libDir {foo[get-version-number]}.
-#
-# Each pkginfo flag corresponds to one piece of extension package
-# info.  Teaish provides usable default values for all of these flags,
-# but at least the -name and -version should be set by clients.
-# e.g. the default -name is the directory name the extension lives in,
-# which may change (e.g. when building it from a "make dist" bundle).
-#
-# The flags:
-#
-#    -name theName: The extension's name. It defaults to the name of the
-#     directory containing the extension. (In TEA this would be the
-#     PACKAGE_NAME, not to be confused with...)
-#
-#    -name.pkg pkg-provide-name: The extension's name for purposes of
-#     Tcl_PkgProvide(), [package require], and friends. It defaults to
-#     the `-name`, and is normally the same, but some projects (like
-#     SQLite) have a different name here than they do in their
-#     historical TEA PACKAGE_NAME.
-#
-#    -version version: The extension's package version. Defaults to
-#     0.0.0.
-#
-#    -libDir dirName: The base name of the directory into which this
-#     extension should be installed. It defaults to a concatenation of
-#     `-name.pkg` and `-version`.
-#
-#    -loadPrefix prefix: For use as the second argument passed to
-#     Tcl's `load` command in the package-loading process. It defaults
-#     to title-cased `-name.pkg` because Tcl's `load` plugin system
-#     expects it in that form.
-#
-#    -options {...}: If provided, it must be a list compatible with
-#     Autosetup's `options-add` function. These can also be set up via
-#     `teaish-options`.
-#
-#    -vsatisfies {{...} ...}: Expects a list-of-lists of conditions
-#     for Tcl's `package vsatisfies` command: each list entry is a
-#     sub-list of `{PkgName Condition...}`.  Teaish inserts those
-#     checks via its default pkgIndex.tcl.in and _teaish.tester.tcl.in
-#     templates to verify that the system's package dependencies meet
-#     these requirements. The default value is `{{Tcl 8.5-}}` (recall
-#     that it's a list-of-lists), as 8.5 is the minimum Tcl version
-#     teaish will run on, but some extensions may require newer
-#     versions or dependencies on other packages. As a special case,
-#     if `-vsatisfies` is given a single token, e.g. `8.6-`, then it
-#     is transformed into `{Tcl $thatToken}`, i.e. it checks the Tcl
-#     version which the package is being run with.  If given multiple
-#     lists, each `package provides` check is run in the given
-#     order. Failure to meet a `vsatisfies` condition triggers an
-#     error.
-#
-#    -url {...}: an optional URL for the extension.
-#
-#    -pragmas {...}  A list of infrequently-needed lower-level
-#     directives which can influence teaish, including:
-#
-#      static-pkgIndex.tcl: tells teaish that the client manages their
-#      own pkgIndex.tcl, so that teaish won't try to overwrite it
-#      using a template.
-#
-#      no-dist: tells teaish to elide the "make dist" recipe from the
-#      makefile so that the client can implement it.
-#
-#      no-dll: tells teaish to elide the makefile rules which build
-#      the DLL, as well as any templated test script and pkgIndex.tcl
-#      references to them. The intent here is to (A) support
-#      client-defined build rules for the DLL and (B) eventually
-#      support script-only extensions.
-#
-# Unsupported flags or pragmas will trigger an error.
-#
-# Potential pothole: setting certain state, e.g. -version, after the
-# initial call requires recalculating of some [define]s. Any such
-# changes should be made as early as possible in teaish-configure so
-# that any later use of those [define]s gets recorded properly (not
-# with the old value).  This is particularly relevant when it is not
-# possible to determine the -version or -name until teaish-configure
-# has been called, and it's updated dynamically from
-# teaish-configure. Notably:
-#
-#   - If -version or -name are updated, -libDir will almost certainly
-#     need to be explicitly set along with them.
-#
-#   - If -name is updated, -loadPrefix probably needs to be as well.
-#
-proc teaish-pkginfo-set {args} {
-  set doVars 0
-  set doCommands 0
-  set xargs $args
-  set recalc {}
-  foreach arg $args {
-    switch -exact -- $arg {
-      -vars {
-        incr doVars
-        set xargs [lassign $xargs -]
-      }
-      -subst {
-        incr doVars
-        incr doCommands
-        set xargs [lassign $xargs -]
-      }
-      default {
-        break
-      }
-    }
-  }
-  set args $xargs
-  unset xargs
-  if {1 == [llength $args] && [llength [lindex $args 0]] > 1} {
-    # Transform a single {...} arg into the canonical call form
-    set a [list {*}[lindex $args 0]]
-    if {$doVars || $doCommands} {
-      set sflags -nobackslashes
-      if {!$doCommands} {
-        lappend sflags -nocommands
-      }
-      set a [uplevel 1 [list subst {*}$sflags $a]]
-    }
-    set args $a
-  }
-  set sentinel "<nope>"
-  set flagDefs [list]
-  foreach {f d} $::teaish__Config(pkginfo-f2d) {
-    lappend flagDefs $f => $sentinel
-  }
-  proj-parse-simple-flags args flags $flagDefs
-  if {[llength $args]} {
-    proj-error -up "Too many (or unknown) arguments to [proj-scope]: $args"
-  }
-  foreach {f d} $::teaish__Config(pkginfo-f2d) {
-    if {$sentinel eq [set v $flags($f)]} continue
-    switch -exact -- $f {
-
-      -options {
-        proj-assert {"" eq $d}
-        options-add $v
-      }
-
-      -pragmas {
-        teaish__pragma {*}$v
-      }
-
-      -vsatisfies {
-        if {1 == [llength $v] && 1 == [llength [lindex $v 0]]} {
-          # Transform X to {Tcl $X}
-          set v [list [join [list Tcl $v]]]
-        }
-        define $d $v
-      }
-
-      -pkgInit.tcl -
-      -pkgInit.tcl.in {
-        if {0x22 & $::teaish__Config(pkginit-policy)} {
-          proj-fatal "Cannot use -pkgInit.tcl(.in) more than once."
-        }
-        set x [file join $::teaish__Config(extension-dir) $v]
-        set tTail [file tail $v]
-        if {"-pkgInit.tcl.in" eq $f} {
-          # Generate pkginit file X from X.in
-          set pI 0x02
-          set tIn $x
-          set tOut [file rootname $tTail]
-          set other -pkgInit.tcl
-        } else {
-          # Static pkginit file X
-          set pI 0x20
-          set tIn ""
-          set tOut $x
-          set other -pkgInit.tcl.in
-        }
-        set ::teaish__Config(pkginit-policy) $pI
-        set ::teaish__PkgInfo($other) {}
-        define TEAISH_PKGINIT_TCL_IN $tIn
-        define TEAISH_PKGINIT_TCL $tOut
-        define TEAISH_PKGINIT_TCL_TAIL $tTail
-        teaish-dist-add $v
-        set v $x
-      }
-
-      -src {
-        set d $::teaish__Config(extension-dir)
-        foreach f $v {
-          lappend ::teaish__Config(dist-files) $f
-          lappend ::teaish__Config(extension-src) $d/$f
-          lappend ::teaish__PkgInfo(-src) $f
-          # ^^^ so that default-value initialization in
-          # teaish-configure-core recognizes that it's been set.
-        }
-      }
-
-      -tm.tcl -
-      -tm.tcl.in {
-        if {0x30 & $::teaish__Config(pkgindex-policy)} {
-          proj-fatal "Cannot use $f together with a pkgIndex.tcl."
-        } elseif {$::teaish__Config(tm-policy)} {
-          proj-fatal "Cannot use -tm.tcl(.in) more than once."
-        }
-        set x [file join $::teaish__Config(extension-dir) $v]
-        if {"-tm.tcl.in" eq $f} {
-          # Generate tm file X from X.in
-          set pT 0x02
-          set pI 0x100
-          set tIn $x
-          set tOut [file rootname [file tail $v]]
-          set other -tm.tcl
-        } else {
-          # Static tm file X
-          set pT 0x20
-          set pI 0x200
-          set tIn ""
-          set tOut $x
-          set other -tm.tcl.in
-        }
-        set ::teaish__Config(pkgindex-policy) $pI
-        set ::teaish__Config(tm-policy) $pT
-        set ::teaish__PkgInfo($other) {}
-        define TEAISH_TM_TCL_IN $tIn
-        define TEAISH_TM_TCL $tOut
-        define TEAISH_PKGINDEX_TCL ""
-        define TEAISH_PKGINDEX_TCL_IN ""
-        define TEAISH_PKGINDEX_TCL_TAIL ""
-        teaish-dist-add $v
-        teaish__pragma no-dll
-        set v $x
-      }
-
-      default {
-        proj-assert {"" ne $d}
-        define $d $v
-      }
-    }
-    set ::teaish__PkgInfo($f) $v
-    if {$f in {-name -version -libDir -loadPrefix}} {
-      lappend recalc $f
-    }
-  }
-  if {"" ne $recalc} {
-    teaish__define_pkginfo_derived $recalc
-  }
-}
-
-#
-# @teaish-pkginfo-get ?arg?
-#
-# If passed no arguments, it returns the extension config info in the
-# same form accepted by teaish-pkginfo-set.
-#
-# If passed one -flagname arg then it returns the value of that config
-# option.
-#
-# Else it treats arg as the name of caller-scoped variable to
-# which this function assigns an array containing the configuration
-# state of this extension, in the same structure accepted by
-# teaish-pkginfo-set. In this case it returns an empty string.
-#
-proc teaish-pkginfo-get {args} {
-  set cases {}
-  set argc [llength $args]
-  set rv {}
-  switch -exact $argc {
-    0 {
-      # Return a list of (-flag value) pairs
-      lappend cases default {{
-        if {[info exists ::teaish__PkgInfo($flag)]} {
-          lappend rv $flag $::teaish__PkgInfo($flag)
-        } else {
-          lappend rv $flag [get-define $defName]
-        }
-      }}
-    }
-
-    1 {
-      set arg $args
-      if {[string match -* $arg]} {
-        # Return the corresponding -flag's value
-        lappend cases $arg {{
-          if {[info exists ::teaish__PkgInfo($flag)]} {
-            return $::teaish__PkgInfo($flag)
-          } else {
-            return [get-define $defName]
-          }
-        }}
-      } else {
-        # Populate target with an array of (-flag value).
-        upvar $arg tgt
-        array set tgt {}
-        lappend cases default {{
-          if {[info exists ::teaish__PkgInfo($flag)]} {
-            set tgt($flag) $::teaish__PkgInfo($flag)
-          } else {
-            set tgt($flag) [get-define $defName]
-          }
-        }}
-      }
-    }
-
-    default {
-      proj-error "invalid arg count from [proj-scope 1]"
-    }
-  }
-
-  foreach {flag defName} $::teaish__Config(pkginfo-f2d) {
-    switch -exact -- $flag [join $cases]
-  }
-  if {0 == $argc} { return $rv }
-}
-
-# (Re)set some defines based on pkginfo state. $flags is the list of
-# pkginfo -flags which triggered this, or "*" for the initial call.
-proc teaish__define_pkginfo_derived {flags} {
-  set all [expr {{*} in $flags}]
-  if {$all || "-version" in $flags || "-name" in $flags} {
-    set name $::teaish__PkgInfo(-name) ; # _not_ -name.pkg
-    if {[info exists ::teaish__PkgInfo(-version)]} {
-      set pkgver $::teaish__PkgInfo(-version)
-      set libname "lib"
-      if {[string match *-cygwin [get-define host]]} {
-        set libname cyg
-      }
-      define TEAISH_DLL8_BASENAME $libname$name$pkgver
-      define TEAISH_DLL9_BASENAME ${libname}tcl9$name$pkgver
-      set ext [get-define TARGET_DLLEXT]
-      define TEAISH_DLL8 [get-define TEAISH_DLL8_BASENAME]$ext
-      define TEAISH_DLL9 [get-define TEAISH_DLL9_BASENAME]$ext
-    }
-  }
-  if {$all || "-libDir" in $flags} {
-    if {[info exists ::teaish__PkgInfo(-libDir)]} {
-      define TCLLIBDIR \
-        [file dirname [get-define TCLLIBDIR]]/$::teaish__PkgInfo(-libDir)
-    }
-  }
-}
-
-#
-# @teaish-checks-queue -pre|-post args...
-#
-# Queues one or more arbitrary "feature test" functions to be run when
-# teaish-checks-run is called. $flag must be one of -pre or -post to
-# specify whether the tests should be run before or after
-# teaish-configure is run. Each additional arg is the name of a
-# feature-test proc.
-#
-proc teaish-checks-queue {flag args} {
-  if {$flag ni {-pre -post}} {
-    proj-error "illegal flag: $flag"
-  }
-  lappend ::teaish__Config(queued-checks${flag}) {*}$args
-}
-
-#
-# @teaish-checks-run -pre|-post
-#
-# Runs all feature checks queued using teaish-checks-queue
-# then cleares the queue.
-#
-proc teaish-checks-run {flag} {
-  if {$flag ni {-pre -post}} {
-    proj-error "illegal flag: $flag"
-  }
-  #puts "*** running $flag: $::teaish__Config(queued-checks${flag})"
-  set foo 0
-  foreach f $::teaish__Config(queued-checks${flag}) {
-    if {![teaish-feature-cache-check $f foo]} {
-      set v [$f]
-      teaish-feature-cache-set $f $v
-    }
-  }
-  set ::teaish__Config(queued-checks${flag}) {}
-}
-
-#
-# A general-purpose getter for various teaish state. Requires one
-# flag, which determines its result value. Flags marked with [L] below
-# are safe for using at load-time, before teaish-pkginfo-set is called
-#
-#   -dir [L]: returns the extension's directory, which may differ from
-#    the teaish core dir or the build dir.
-#
-#   -teaish-home [L]: the "home" dir of teaish itself, which may
-#   differ from the extension dir or build dir.
-#
-#   -build-dir [L]: the build directory (typically the current working
-#   -dir).
-#
-#   Any of the teaish-pkginfo-get/get flags: returns the same as
-#   teaish-pkginfo-get. Not safe for use until teaish-pkginfo-set has
-#   been called.
-#
-# Triggers an error if passed an unknown flag.
-#
-proc teaish-get {flag} {
-  #-teaish.tcl {return $::teaish__Config(teaish.tcl)}
-  switch -exact -- $flag {
-    -dir {
-      return $::teaish__Config(extension-dir)
-    }
-    -teaish-home {
-      return $::autosetup(srcdir)
-    }
-    -build-dir {
-      return $::autosetup(builddir)
-    }
-    default {
-      if {[info exists ::teaish__PkgInfo($flag)]} {
-        return $::teaish__PkgInfo($flag)
-      }
-    }
-  }
-  proj-error "Unhandled flag: $flag"
-}
-
-#
-# Handles --teaish-create-extension=TARGET-DIR
-#
-proc teaish__create_extension {dir} {
-  set force [opt-bool teaish-force]
-  if {"" eq $dir} {
-    proj-error "--teaish-create-extension=X requires a directory name."
-  }
-  file mkdir $dir/generic
-  set cwd [pwd]
-  #set dir [file-normalize [file join $cwd $dir]]
-  teaish__verbose 1 msg-result "Created dir $dir"
-  cd $dir
-  if {!$force} {
-    # Ensure that we don't blindly overwrite anything
-    foreach f {
-      generic/teaish.c
-      teaish.tcl
-      teaish.make.in
-      teaish.test.tcl
-    } {
-      if {[file exists $f]} {
-        error "Cowardly refusing to overwrite $dir/$f. Use --teaish-force to overwrite."
-      }
-    }
-  }
-
-  set name [file tail $dir]
-  set pkgName $name
-  set version 0.0.1
-  set loadPrefix [string totitle $pkgName]
-  set content {teaish-pkginfo-set }
-  #puts "0 content=$content"
-  if {[opt-str teaish-extension-pkginfo epi]} {
-    set epi [string trim $epi]
-    if {[string match "*\n*" $epi]} {
-      set epi "{$epi}"
-    } elseif {![string match "{*}" $epi]} {
-      append content "\{" $epi "\}"
-    } else {
-      append content $epi
-    }
-    #puts "2 content=$content\nepi=$epi"
-  } else {
-    append content [subst -nocommands -nobackslashes {{
-      -name ${name}
-      -name.pkg ${pkgName}
-      -name.dist ${pkgName}
-      -version ${version}
-      -loadPrefix $loadPrefix
-      -libDir ${name}${version}
-      -vsatisfies {{Tcl 8.5-}}
-      -url {}
-      -options {}
-      -pragmas {full-dist}
-    }}]
-    #puts "3 content=$content"
-  }
-  #puts "1 content=$content"
-  append content "\n" {
-#proc teaish-options {} {
-  # Return a list and/or use \[options-add\] to add new
-  # configure flags. This is called before teaish's
-  # bootstrapping is finished, so only teaish-*
-  # APIs which are explicitly noted as being safe
-  # early on may be used here. Any autosetup-related
-  # APIs may be used here.
-  #
-  # Return an empty string if there are no options to
-  # add or if they are added using \[options-add\].
-  #
-  # If there are no options to add, this proc need
-  # not be defined.
-#}
-
-# Called by teaish once bootstrapping is complete.
-# This function is responsible for the client-specific
-# parts of the configuration process.
-proc teaish-configure {} {
-  teaish-src-add -dir -dist generic/teaish.c
-  teaish-define-to-cflag -quote TEAISH_PKGNAME TEAISH_VERSION
-
-  # TODO: your code goes here..
-}
-}; # $content
-  proj-file-write teaish.tcl $content
-  teaish__verbose 1 msg-result "Created teaish.tcl"
-
-  set content "# Teaish test script.
-# When this tcl script is invoked via 'make test' it will have loaded
-# the package, run any teaish.pkginit.tcl code, and loaded
-# autosetup/teaish/tester.tcl.
-"
-  proj-file-write teaish.test.tcl $content
-  teaish__verbose 1 msg-result "Created teaish.test.tcl"
-
-  set content [subst -nocommands -nobackslashes {
-#include <tcl.h>
-static int
-${loadPrefix}_Cmd(ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]){
-  Tcl_SetObjResult(interp, Tcl_NewStringObj("this is the ${name} extension", -1));
-  return TCL_OK;
-}
-
-extern int DLLEXPORT ${loadPrefix}_Init(Tcl_Interp *interp){
-  if (Tcl_InitStubs(interp, TCL_VERSION, 0) == NULL) {
-    return TCL_ERROR;
-  }
-  if (Tcl_PkgProvide(interp, TEAISH_PKGNAME, TEAISH_VERSION) == TCL_ERROR) {
-    return TCL_ERROR;
-  }
-  Tcl_CreateObjCommand(interp, TEAISH_PKGNAME, ${loadPrefix}_Cmd, NULL, NULL);
-  return TCL_OK;
-}
-}]
-  proj-file-write generic/teaish.c $content
-  teaish__verbose 1 msg-result "Created generic/teaish.c"
-
-  set content "# teaish makefile for the ${name} extension
-# tx.src      = \$(tx.dir)/generic/teaish.c
-# tx.LDFLAGS  =
-# tx.CFLAGS   =
-"
-  proj-file-write teaish.make.in $content
-  teaish__verbose 1 msg-result "Created teaish.make.in"
-
-  msg-result "Created new extension \[$dir\]."
-
-  cd $cwd
-  set ::teaish__Config(install-ext-dir) $dir
-}
-
-#
-# Internal helper for teaish__install
-#
-proc teaish__install_file {f destDir force} {
-  set dest $destDir/[file tail $f]
-  if {[file isdirectory $f]} {
-    file mkdir $dest
-  } elseif {!$force && [file exists $dest]} {
-    array set st1 [file stat $f]
-    array set st2 [file stat $dest]
-    if {($st1(mtime) == $st2(mtime))
-        && ($st1(size) == $st2(size))} {
-      if {[file tail $f] in {
-        pkgIndex.tcl.in
-        _teaish.tester.tcl.in
-      }} {
-        # Assume they're the same. In the scope of the "make dist"
-        # rules, this happens legitimately when an extension with a
-        # copy of teaish installed in the same dir assumes that the
-        # pkgIndex.tcl.in and _teaish.tester.tcl.in belong to the
-        # extension, whereas teaish believes they belong to teaish.
-        # So we end up with dupes of those.
-        return
-      }
-    }
-    proj-error -up "Cowardly refusing to overwrite \[$dest\]." \
-      "Use --teaish-force to enable overwriting."
-  } else {
-    # file copy -force $f $destDir; # loses +x bit
-    #
-    # JimTcl doesn't have [file attribute], so we can't use that here
-    # (in the context of an autosetup configure script).
-    exec cp -p $f $dest
-  }
-}
-
-#
-# Installs a copy of teaish, with autosetup, to $dDest, which defaults
-# to the --teaish-install=X or --teash-create-extension=X dir. Won't
-# overwrite files unless --teaish-force is used.
-#
-proc teaish__install {{dDest ""}} {
-  if {$dDest in {auto ""}} {
-    set dDest [opt-val teaish-install]
-    if {$dDest in {auto ""}} {
-      if {[info exists ::teaish__Config(install-ext-dir)]} {
-        set dDest $::teaish__Config(install-ext-dir)
-      }
-    }
-  }
-  set force [opt-bool teaish-force]
-  if {$dDest in {auto ""}} {
-    proj-error "Cannot determine installation directory."
-  } elseif {!$force && [file exists $dDest/auto.def]} {
-    proj-error \
-      "Target dir looks like it already contains teaish and/or autosetup: $dDest" \
-      "\nUse --teaish-force to overwrite it."
-  }
-
-  set dSrc $::autosetup(srcdir)
-  set dAS $::autosetup(libdir)
-  set dAST $::teaish__Config(core-dir)
-  set dASTF $dAST/feature
-  teaish__verbose 1 msg-result "Installing teaish to \[$dDest\]..."
-  if {$::teaish__Config(verbose)>1} {
-    msg-result "dSrc  = $dSrc"
-    msg-result "dAS   = $dAS"
-    msg-result "dAST  = $dAST"
-    msg-result "dASTF = $dASTF"
-    msg-result "dDest = $dDest"
-  }
-
-  # Dest subdirs...
-  set ddAS   $dDest/autosetup
-  set ddAST  $ddAS/teaish
-  set ddASTF $ddAST/feature
-  foreach {srcDir destDir} [list \
-                              $dAS   $ddAS \
-                              $dAST  $ddAST \
-                              $dASTF $ddASTF \
-                             ] {
-    teaish__verbose 1 msg-result "Copying files to $destDir..."
-    file mkdir $destDir
-    foreach f  [glob -nocomplain -directory $srcDir *] {
-      if {[string match {*~} $f] || [string match "#*#" [file tail $f]]} {
-        # Editor-generated backups and emacs lock files
-        continue
-      }
-      teaish__verbose 2 msg-result "\t$f"
-      teaish__install_file $f $destDir $force
-    }
-  }
-  teaish__verbose 1 msg-result "Copying files to $dDest..."
-  foreach f {
-    auto.def configure Makefile.in pkgIndex.tcl.in
-    _teaish.tester.tcl.in
-  } {
-    teaish__verbose 2 msg-result "\t$f"
-    teaish__install_file $dSrc/$f $dDest $force
-  }
-  set ::teaish__Config(install-self-dir) $dDest
-  msg-result "Teaish $::teaish__Config(version) installed in \[$dDest\]."
-}
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/teaish/feature.tcl b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/teaish/feature.tcl
deleted file mode 100644
index 6c927d1..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/teaish/feature.tcl
+++ /dev/null
@@ -1,214 +0,0 @@
-########################################################################
-# 2025 April 7
-#
-# The author disclaims copyright to this source code.  In place of
-# a legal notice, here is a blessing:
-#
-#  * May you do good and not evil.
-#  * May you find forgiveness for yourself and forgive others.
-#  * May you share freely, never taking more than you give.
-#
-########################################################################
-# ----- @module feature-tests.tcl -----
-# @section TEA-ish collection of feature tests.
-#
-# Functions in this file with a prefix of teaish__ are
-# private/internal APIs. Those with a prefix of teaish- are
-# public APIs.
-
-
-# @teaish-check-libz
-#
-# Checks for zlib.h and the function deflate in libz. If found,
-# prepends -lz to the extension's ldflags and returns 1, else returns
-# 0. It also defines LDFLAGS_LIBZ to the libs flag.
-#
-proc teaish-check-libz {} {
-  teaish-check-cached "Checking for libz" {
-    set rc 0
-    if {[msg-quiet cc-check-includes zlib.h] && [msg-quiet proj-check-function-in-lib deflate z]} {
-      teaish-ldflags-prepend [define LDFLAGS_LIBZ [get-define lib_deflate]]
-      undefine lib_deflate
-      incr rc
-    }
-    expr $rc
-  }
-}
-
-# @teaish-check-librt ?funclist?
-#
-# Checks whether -lrt is needed for any of the given functions.  If
-# so, appends -lrt via [teaish-ldflags-prepend] and returns 1, else
-# returns 0. It also defines LDFLAGS_LIBRT to the libs flag or an
-# empty string.
-#
-# Some systems (ex: SunOS) require -lrt in order to use nanosleep.
-#
-proc teaish-check-librt {{funclist {fdatasync nanosleep}}} {
-  teaish-check-cached -nostatus "Checking whether ($funclist) need librt" {
-    define LDFLAGS_LIBRT ""
-    foreach func $funclist {
-      if {[msg-quiet proj-check-function-in-lib $func rt]} {
-        set ldrt [get-define lib_${func}]
-        undefine lib_${func}
-        if {"" ne $ldrt} {
-          teaish-ldflags-prepend -r [define LDFLAGS_LIBRT $ldrt]
-          msg-result $ldrt
-          return 1
-        } else {
-          msg-result "no lib needed"
-          return 1
-        }
-      }
-    }
-    msg-result "not found"
-    return 0
-  }
-}
-
-# @teaish-check-stdint
-#
-# A thin proxy for [cc-with] which checks for <stdint.h> and the
-# various fixed-size int types it declares. It defines HAVE_STDINT_T
-# to 0 or 1 and (if it's 1) defines HAVE_XYZ_T for each XYZ int type
-# to 0 or 1, depending on whether its available.
-proc teaish-check-stdint {} {
-  teaish-check-cached "Checking for stdint.h" {
-    msg-quiet cc-with {-includes stdint.h} \
-      {cc-check-types int8_t int16_t int32_t int64_t intptr_t \
-         uint8_t uint16_t uint32_t uint64_t uintptr_t}
-  }
-}
-
-# @teaish-is-mingw
-#
-# Returns 1 if building for mingw, else 0.
-proc teaish-is-mingw {} {
-  return [expr {
-    [string match *mingw* [get-define host]] &&
-    ![file exists /dev/null]
-  }]
-}
-
-# @teaish-check-libdl
-#
-# Checks for whether dlopen() can be found and whether it requires
-# -ldl for linking. If found, returns 1, defines LDFLAGS_DLOPEN to the
-# linker flags (if any), and passes those flags to
-# teaish-ldflags-prepend. It unconditionally defines HAVE_DLOPEN to 0
-# or 1 (the its return result value).
-proc teaish-check-dlopen {} {
-  teaish-check-cached -nostatus "Checking for dlopen()" {
-    set rc 0
-    set lfl ""
-    if {[cc-with {-includes dlfcn.h} {
-      cctest -link 1 -declare "extern char* dlerror(void);" -code "dlerror();"}]} {
-      msg-result "-ldl not needed"
-      incr rc
-    } elseif {[cc-check-includes dlfcn.h]} {
-      incr rc
-      if {[cc-check-function-in-lib dlopen dl]} {
-        set lfl [get-define lib_dlopen]
-        undefine lib_dlopen
-        msg-result " dlopen() needs $lfl"
-      } else {
-        msg-result " - dlopen() not found in libdl. Assuming dlopen() is built-in."
-      }
-    } else {
-      msg-result "not found"
-    }
-    teaish-ldflags-prepend [define LDFLAGS_DLOPEN $lfl]
-    define HAVE_DLOPEN $rc
-  }
-}
-
-#
-# @teaish-check-libmath
-#
-# Handles the --enable-math flag. Returns 1 if found, else 0.
-# If found, it prepends -lm (if needed) to the linker flags.
-proc teaish-check-libmath {} {
-  teaish-check-cached "Checking for libc math library" {
-    set lfl ""
-    set rc 0
-    if {[msg-quiet proj-check-function-in-lib ceil m]} {
-      incr rc
-      set lfl [get-define lib_ceil]
-      undefine lib_ceil
-      teaish-ldflags-prepend $lfl
-      msg-checking "$lfl "
-    }
-    define LDFLAGS_LIBMATH $lfl
-    expr $rc
-  }
-}
-
-# @teaish-import-features ?-flags? feature-names...
-#
-# For each $name in feature-names... it invokes:
-#
-#   use teaish/feature/$name
-#
-# to load TEAISH_AUTOSETUP_DIR/feature/$name.tcl
-#
-# By default, if a proc named teaish-check-${name}-options is defined
-# after sourcing a file, it is called and its result is passed to
-# proj-append-options. This can be suppressed with the -no-options
-# flag.
-#
-# Flags:
-#
-#   -no-options: disables the automatic running of
-#    teaish-check-NAME-options,
-#
-#   -run: if the function teaish-check-NAME exists after importing
-#    then it is called. This flag must not be used when calling this
-#    function from teaish-options. This trumps both -pre and -post.
-#
-#   -pre: if the function teaish-check-NAME exists after importing
-#    then it is passed to [teaish-checks-queue -pre].
-#
-#   -post: works like -pre but instead uses[teaish-checks-queue -post].
-proc teaish-import-features {args} {
-  set pk ""
-  set doOpt 1
-  proj-parse-simple-flags args flags {
-    -no-options 0 {set doOpt 0}
-    -run        0 {expr 1}
-    -pre        0 {set pk -pre}
-    -post       0 {set pk -post}
-  }
-  #
-  # TODO: never import the same module more than once. The "use"
-  # command is smart enough to not do that but we would need to
-  # remember whether or not any teaish-check-${arg}* procs have been
-  # called before, and skip them.
-  #
-  if {$flags(-run) && "" ne $pk} {
-    proj-error "Cannot use both -run and $pk" \
-      " (called from [proj-scope 1])"
-  }
-
-  foreach arg $args {
-    uplevel "use teaish/feature/$arg"
-    if {$doOpt} {
-      set n "teaish-check-${arg}-options"
-      if {[llength [info proc $n]] > 0} {
-        if {"" ne [set x [$n]]} {
-          options-add $x
-        }
-      }
-    }
-    if {$flags(-run)} {
-      set n "teaish-check-${arg}"
-      if {[llength [info proc $n]] > 0} {
-        uplevel 1 $n
-      }
-    } elseif {"" ne $pk} {
-      set n "teaish-check-${arg}"
-      if {[llength [info proc $n]] > 0} {
-        teaish-checks-queue {*}$pk $n
-      }
-    }
-  }
-}
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/teaish/tester.tcl b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/teaish/tester.tcl
deleted file mode 100644
index a25b366..0000000
--- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/teaish/tester.tcl
+++ /dev/null
@@ -1,293 +0,0 @@
-########################################################################
-# 2025 April 5
-#
-# The author disclaims copyright to this source code.  In place of
-# a legal notice, here is a blessing:
-#
-#  * May you do good and not evil.
-#  * May you find forgiveness for yourself and forgive others.
-#  * May you share freely, never taking more than you give.
-#
-########################################################################
-#
-# Helper routines for running tests on teaish extensions
-#
-########################################################################
-# ----- @module teaish/tester.tcl -----
-#
-# @section TEA-ish Testing APIs.
-#
-# Though these are part of the autosup dir hierarchy, they are not
-# intended to be run from autosetup code. Rather, they're for use
-# with/via teaish.tester.tcl and target canonical Tcl only, not JimTcl
-# (which the autosetup pieces do target).
-
-#
-# @test-current-scope ?lvl?
-#
-# Returns the name of the _calling_ proc from ($lvl + 1) levels up the
-# call stack (where the caller's level will be 1 up from _this_
-# call). If $lvl would resolve to global scope "global scope" is
-# returned and if it would be negative then a string indicating such
-# is returned (as opposed to throwing an error).
-#
-proc test-current-scope {{lvl 0}} {
-  #uplevel [expr {$lvl + 1}] {lindex [info level 0] 0}
-  set ilvl [info level]
-  set offset [expr {$ilvl  - $lvl - 1}]
-  if { $offset < 0} {
-    return "invalid scope ($offset)"
-  } elseif { $offset == 0} {
-    return "global scope"
-  } else {
-    return [lindex [info level $offset] 0]
-  }
-}
-
-# @test-msg
-#
-# Emits all arugments to stdout.
-#
-proc test-msg {args} {
-  puts "$args"
-}
-
-# @test-warn
-#
-# Emits all arugments to stderr.
-#
-proc test-warn {args} {
-  puts stderr "WARNING: $args"
-}
-
-#
-# @test-error msg
-#
-# Triggers a test-failed error with a string describing the calling
-# scope and the provided message.
-#
-proc test-fail {args} {
-  #puts stderr "ERROR: \[[test-current-scope 1]]: $msg"
-  #exit 1
-  error "FAIL: \[[test-current-scope 1]]: $args"
-}
-
-array set ::test__Counters {}
-array set ::test__Config {
-  verbose-assert 0 verbose-affirm 0
-}
-
-# Internal impl for affirm and assert.
-#
-# $args = ?-v? script {msg-on-fail ""}
-proc test__affert {failMode args} {
-  if {$failMode} {
-    set what assert
-  } else {
-    set what affirm
-  }
-  set verbose $::test__Config(verbose-$what)
-  if {"-v" eq [lindex $args 0]} {
-    lassign $args - script msg
-    if {1 == [llength $args]} {
-      # If -v is the only arg, toggle default verbose mode
-      set ::test__Config(verbose-$what) [expr {!$::test__Config(verbose-$what)}]
-      return
-    }
-    incr verbose
-  } else {
-    lassign $args script msg
-  }
-  incr ::test__Counters($what)
-  if {![uplevel 1 expr [list $script]]} {
-    if {"" eq $msg} {
-      set msg $script
-    }
-    set txt [join [list $what # $::test__Counters($what) "failed:" $msg]]
-    if {$failMode} {
-      puts stderr $txt
-      exit 1
-    } else {
-      error $txt
-    }
-  } elseif {$verbose} {
-    puts stderr [join [list $what # $::test__Counters($what) "passed:" $script]]
-  }
-}
-
-#
-# @affirm ?-v? script ?msg?
-#
-# Works like a conventional assert method does, but reports failures
-# using [error] instead of [exit]. If -v is used, it reports passing
-# assertions to stderr. $script is evaluated in the caller's scope as
-# an argument to [expr].
-#
-proc affirm {args} {
-  tailcall test__affert 0 {*}$args
-}
-
-#
-# @assert ?-v? script ?msg?
-#
-# Works like [affirm] but exits on error.
-#
-proc assert {args} {
-  tailcall test__affert 1 {*}$args
-}
-
-#
-# @assert-matches ?-e? pattern ?-e? rhs ?msg?
-#
-# Equivalent to assert {[string match $pattern $rhs]} except that
-# if either of those are prefixed with an -e flag, they are eval'd
-# and their results are used.
-#
-proc assert-matches {args} {
-  set evalLhs 0
-  set evalRhs 0
-  if {"-e" eq [lindex $args 0]} {
-    incr evalLhs
-    set args [lassign $args -]
-  }
-  set args [lassign $args pattern]
-  if {"-e" eq [lindex $args 0]} {
-    incr evalRhs
-    set args [lassign $args -]
-  }
-  set args [lassign $args rhs msg]
-
-  if {$evalLhs} {
-    set pattern [uplevel 1 $pattern]
-  }
-  if {$evalRhs} {
-    set rhs [uplevel 1 $rhs]
-  }
-  #puts "***pattern=$pattern\n***rhs=$rhs"
-  tailcall test__affert 1 \
-    [join [list \[ string match [list $pattern] [list $rhs] \]]] $msg
-  # why does this not work? [list \[ string match [list $pattern] [list $rhs] \]] $msg
-  # "\[string match [list $pattern] [list $rhs]\]"
-}
-
-#
-# @test-assert testId script ?msg?
-#
-# Works like [assert] but emits $testId to stdout first.
-#
-proc test-assert {testId script {msg ""}} {
-  puts "test $testId"
-  tailcall test__affert 1 $script $msg
-}
-
-#
-# @test-expect testId script result
-#
-# Runs $script in the calling scope and compares its result to
-# $result, minus any leading or trailing whitespace.  If they differ,
-# it triggers an [assert].
-#
-proc test-expect {testId script result} {
-  puts "test $testId"
-  set x [string trim [uplevel 1 $script]]
-  set result [string trim $result]
-  tailcall test__affert 0 [list "{$x}" eq "{$result}"] \
-    "\nEXPECTED: <<$result>>\nGOT:      <<$x>>"
-}
-
-#
-# @test-catch cmd ?...args?
-#
-# Runs [cmd ...args], repressing any exception except to possibly log
-# the failure. Returns 1 if it caught anything, 0 if it didn't.
-#
-proc test-catch {cmd args} {
-  if {[catch {
-    uplevel 1 $cmd {*}$args
-  } rc xopts]} {
-    puts "[test-current-scope] ignoring failure of: $cmd [lindex $args 0]: $rc"
-    return 1
-  }
-  return 0
-}
-
-#
-# @test-catch-matching pattern (script|cmd args...)
-#
-# Works like test-catch, but it expects its argument(s) to to throw an
-# error matching the given string (checked with [string match]).  If
-# they do not throw, or the error does not match $pattern, this
-# function throws, else it returns 1.
-#
-# If there is no second argument, the $cmd is assumed to be a script,
-# and will be eval'd in the caller's scope.
-#
-# TODO: add -glob and -regex flags to control matching flavor.
-#
-proc test-catch-matching {pattern cmd args} {
-  if {[catch {
-    #puts "**** catch-matching cmd=$cmd args=$args"
-    if {0 == [llength $args]} {
-      uplevel 1 $cmd {*}$args
-    } else {
-      $cmd {*}$args
-    }
-  } rc xopts]} {
-    if {[string match $pattern $rc]} {
-      return 1
-    } else {
-      error "[test-current-scope] exception does not match {$pattern}: {$rc}"
-    }
-  }
-  error "[test-current-scope] expecting to see an error matching {$pattern}"
-}
-
-if {![array exists ::teaish__BuildFlags]} {
-  array set ::teaish__BuildFlags {}
-}
-
-#
-# @teaish-build-flag3 flag tgtVar ?dflt?
-#
-# If the current build has the configure-time flag named $flag set
-# then tgtVar is assigned its value and 1 is returned, else tgtVal is
-# assigned $dflt and 0 is returned.
-#
-# Caveat #1: only valid when called in the context of teaish's default
-# "make test" recipe, e.g. from teaish.test.tcl. It is not valid from
-# a teaish.tcl configure script because (A) the state it relies on
-# doesn't fully exist at that point and (B) that level of the API has
-# more direct access to the build state. This function requires that
-# an external script have populated its internal state, which is
-# normally handled via teaish.tester.tcl.in.
-#
-# Caveat #2: defines in the style of HAVE_FEATURENAME with a value of
-# 0 are, by long-standing configure script conventions, treated as
-# _undefined_ here.
-#
-proc teaish-build-flag3 {flag tgtVar {dflt ""}} {
-  upvar $tgtVar tgt
-  if {[info exists ::teaish__BuildFlags($flag)]} {
-    set tgt $::teaish__BuildFlags($flag)
-    return 1;
-  } elseif {0==[array size ::teaish__BuildFlags]} {
-    test-warn \
-      "\[[test-current-scope]] was called from " \
-      "[test-current-scope 1] without the build flags imported."
-  }
-  set tgt $dflt
-  return 0
-}
-
-#
-# @teaish-build-flag flag ?dflt?
-#
-# Convenience form of teaish-build-flag3 which returns the
-# configure-time-defined value of $flag or "" if it's not defined (or
-# if it's an empty string).
-#
-proc teaish-build-flag {flag {dflt ""}} {
-  set tgt ""
-  teaish-build-flag3 $flag tgt $dflt
-  return $tgt
-}