Embed tclreadline Tcl scripts into the silisizer binary

The interactive prompt previously searched the filesystem for
tclreadlineInit.tcl/Setup.tcl at run time and printed
"tclreadlineInit.tcl not found; interactive line editing disabled"
whenever the bundled scripts were missing or relocated.

Vendor the tclreadline v2.4.1 Setup + Completer scripts under src/tcl/,
encode them into the executable via OpenSTA's TclEncode.tcl (the same
mechanism used for tcl_inits), and evaluate them at startup. This removes
the external file dependency entirely. The vendored Setup only re-provides
the tclreadline package if the statically-linked C library has not already
done so, avoiding a version-conflict error (the v2.4.1 release reports
2.4.0). Drop the now-redundant script-bundling steps from the release
workflow; only libtclreadline itself still needs bundling.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: akashlevy

.github/workflows/release.yml

@@ -107,11 +107,8 @@ jobs:
               TCL_LIB_DIR=$(find /usr/lib /usr/local/lib -maxdepth 1 -name "tcl8.6" -type d 2>/dev/null | head -1)
               [ -d "$TCL_LIB_DIR" ] && cp -r "$TCL_LIB_DIR" $STAGE/lib/tcl8.6
 
-              # Bundle tclreadline scripts (tclreadlineInit.tcl etc.) so the
-              # interactive prompt works in the relocated install.
-              for d in /usr/local/lib/tclreadline*; do
-                [ -d "$d" ] && cp -r "$d" "$STAGE/lib/"
-              done
+              # The tclreadline Tcl scripts are embedded in the silisizer
+              # binary, so only the shared library (bundled above) is needed.
 
               for f in "$STAGE"/bin/*; do
                 [ -f "$f" ] && patchelf --set-rpath "\$ORIGIN/../lib" "$f" 2>/dev/null || true
@@ -289,11 +286,8 @@ jobs:
               echo "TCL_LIB_DIR: $TCL_LIB_DIR"
               [ -d "$TCL_LIB_DIR" ] && cp -a "$TCL_LIB_DIR" "$STAGE/lib/tcl8.6"
 
-              # Bundle tclreadline scripts (tclreadlineInit.tcl etc.) so the
-              # interactive prompt works in the relocated install.
-              for d in /usr/local/lib/tclreadline*; do
-                [ -d "$d" ] && cp -a "$d" "$STAGE/lib/"
-              done
+              # The tclreadline Tcl scripts are embedded in the silisizer
+              # binary, so only the shared library (bundled above) is needed.
 
               for f in "$STAGE"/bin/*; do
                 [ -f "$f" ] && patchelf --set-rpath "\$ORIGIN/../lib" "$f" 2>/dev/null || true
@@ -432,11 +426,8 @@ jobs:
           # Bundle Tcl 8.6 library scripts
           cp -r "$(brew --prefix tcl-tk@8)/lib/tcl8.6" $STAGE/lib/tcl8.6
 
-          # Bundle tclreadline scripts (tclreadlineInit.tcl etc.) so the
-          # interactive prompt works in the relocated install.
-          for d in /usr/local/lib/tclreadline*; do
-            [ -d "$d" ] && cp -R "$d" "$STAGE/lib/"
-          done
+          # The tclreadline Tcl scripts are embedded in the silisizer binary,
+          # so only the shared library (bundled above) is needed.
 
           # install_name_tool invalidates the code signature; arm64 macOS
           # refuses to run binaries/dylibs with a stale signature, so re-sign

CMakeLists.txt

@@ -152,6 +152,31 @@ if (WIN32)
   add_compile_definitions(WIN32_LEAN_AND_MEAN)
 endif()
 
+# Embed the tclreadline Tcl scripts (interactive Loop + command completer) into
+# the executable so the interactive prompt has no external file dependency.
+# They are encoded into a C string array (named tclreadline_inits in namespace
+# sta) exactly like OpenSTA's own tcl_inits, then unencoded and evaluated at
+# startup. This removes the need to locate tclreadlineInit.tcl/Setup.tcl on disk.
+set(SILISIZER_TCLRL_INIT "")
+if (TCL_READLINE)
+  set(SILISIZER_TCLRL_TCL_FILES
+    ${PROJECT_SOURCE_DIR}/src/tcl/tclreadlineSetup.tcl
+    ${PROJECT_SOURCE_DIR}/src/tcl/tclreadlineCompleter.tcl
+    ${PROJECT_SOURCE_DIR}/src/tcl/tclreadlineEmbedInit.tcl
+    )
+  set(SILISIZER_TCLRL_INIT ${CMAKE_BINARY_DIR}/SilisizerTclReadlineInitVar.cc)
+  find_program(TCLSH_EXECUTABLE NAMES tclsh tclsh8.6 tclsh8.7 tclsh9.0 tclsh90)
+  if (TCLSH_EXECUTABLE)
+    set(SILISIZER_TCL_ENCODE_CMD ${TCLSH_EXECUTABLE} ${OPENSTA_HOME}/etc/TclEncode.tcl)
+  else()
+    set(SILISIZER_TCL_ENCODE_CMD ${OPENSTA_HOME}/etc/TclEncode.tcl)
+  endif()
+  add_custom_command(OUTPUT ${SILISIZER_TCLRL_INIT}
+    COMMAND ${SILISIZER_TCL_ENCODE_CMD} ${SILISIZER_TCLRL_INIT} tclreadline_inits ${SILISIZER_TCLRL_TCL_FILES}
+    DEPENDS ${SILISIZER_TCLRL_TCL_FILES} ${OPENSTA_HOME}/etc/TclEncode.tcl
+    )
+endif()
+
 set(silisizer_SRC
   ${PROJECT_SOURCE_DIR}/src/Silisizer.cpp
   ${CMAKE_BINARY_DIR}/Silisizer_wrap.cc
@@ -177,7 +202,7 @@ target_include_directories(silisizer PUBLIC
   ${TCL_HEADER_DIR}
   $<INSTALL_INTERFACE:include>)
 
-  add_executable(silisizer-bin ${PROJECT_SOURCE_DIR}/src/main.cpp)
+  add_executable(silisizer-bin ${PROJECT_SOURCE_DIR}/src/main.cpp ${SILISIZER_TCLRL_INIT})
 set_target_properties(silisizer-bin PROPERTIES OUTPUT_NAME silisizer)
 
 if (MSVC OR WIN32)

src/main.cpp

@@ -86,6 +86,11 @@ extern int Sta_Init(Tcl_Interp *interp);
 namespace sta {
 // extern const char *silisizer_tcl_inits[];
 extern const char *tcl_inits[];
+#if TCL_READLINE
+// tclreadline Tcl scripts (Setup + Completer + completer hookup) encoded into
+// the executable by TclEncode.tcl (see SilisizerTclReadlineInitVar.cc).
+extern const char *tclreadline_inits[];
+#endif
 }  // namespace sta
 
 // "Arguments" passed to staTclAppInit.
@@ -157,47 +162,28 @@ static int silisizerTclAppInit(Tcl_Interp *interp) {
   }
 
 #if TCL_READLINE
-  // Initialize the C side of tclreadline. The library is linked into this
-  // binary, so we also register it as a static package and (below) tell the Tcl
-  // init script to skip its own dlopen of libtclreadline. This is what lets
-  // tclreadline keep working in a relocated/packaged install where the shared
-  // library is only reachable via the executable's RPATH.
+  // Initialize the C side of tclreadline and register it as a static package.
+  // The library is linked into this binary (reachable via the executable's
+  // RPATH in a packaged install), so the Tcl scripts below skip their own
+  // dlopen of libtclreadline.
   if (Tclreadline_Init(interp) == TCL_ERROR)
     return TCL_ERROR;
   Tcl_StaticPackage(interp, "tclreadline", Tclreadline_Init, Tclreadline_SafeInit);
 
-  // Locate and source tclreadlineInit.tcl (which sources tclreadlineSetup.tcl
-  // and thereby defines ::tclreadline::Loop). The compile-time TCLRL_LIBRARY
-  // path does not exist once the build is packaged and extracted elsewhere, so
-  // search next to the executable first (the bundled copy), then fall back to
-  // the build-time path, $TCL_LIBRARY and a few standard locations.
+  // The tclreadline Tcl scripts (the interactive ::tclreadline::Loop defined in
+  // tclreadlineSetup.tcl plus the command completer in tclreadlineCompleter.tcl)
+  // are compiled directly into this binary as sta::tclreadline_inits, so there
+  // is no external tclreadlineInit.tcl/Setup.tcl to locate at run time. Decode
+  // and evaluate them now; on failure we fall back to Tcl_Main's plain REPL.
   //
   // Tclreadline_Init() above already created the read-only ::tclreadline::library
-  // variable, so tclreadlineInit.tcl's own "if {![info exists
-  // tclreadline::library]}" guard skips its dlopen of libtclreadline. That keeps
-  // tclreadline working in a relocated install where the shared library is only
-  // reachable via the executable's RPATH. (Do not try to set that variable here:
-  // it is read-only and assigning to it aborts this whole script.)
-  static const char *tclreadline_loader =
-    "namespace eval ::tclreadline {}\n"
-    "proc ::tclreadline::_locate_init {} {\n"
-    "  set bases [list [file join [file dirname [info nameofexecutable]] .. lib] {" TCLRL_LIBRARY "} /usr/local/lib /usr/lib]\n"
-    "  if {[info exists ::env(TCL_LIBRARY)]} { lappend bases $::env(TCL_LIBRARY) [file join $::env(TCL_LIBRARY) ..] }\n"
-    "  foreach base $bases {\n"
-    "    set cands [list [file join $base tclreadlineInit.tcl]]\n"
-    "    foreach g [lsort -decreasing [glob -nocomplain [file join $base tclreadline* tclreadlineInit.tcl]]] { lappend cands $g }\n"
-    "    foreach cand $cands { if {[file exists $cand]} { return $cand } }\n"
-    "  }\n"
-    "  return {}\n"
-    "}\n"
-    "set ::tclreadline::_init_script [::tclreadline::_locate_init]\n"
-    "if {$::tclreadline::_init_script ne {}} {\n"
-    "  if {[catch {source $::tclreadline::_init_script} ::tclreadline::_err]} { puts stderr \"tclreadline: failed to load $::tclreadline::_init_script: $::tclreadline::_err\" }\n"
-    "} else {\n"
-    "  puts stderr {tclreadline: tclreadlineInit.tcl not found; interactive line editing disabled}\n"
-    "}\n";
-  if (Tcl_Eval(interp, tclreadline_loader) != TCL_OK)
-    fprintf(stderr, "tclreadline: setup failed: %s\n", Tcl_GetStringResult(interp));
+  // variable, so the scripts skip their own dlopen of libtclreadline (which is
+  // statically linked here anyway).
+  char *tclreadline_init = sta::unencode(sta::tclreadline_inits);
+  if (Tcl_Eval(interp, tclreadline_init) != TCL_OK)
+    fprintf(stderr, "tclreadline: embedded init failed: %s\n",
+            Tcl_GetStringResult(interp));
+  delete [] tclreadline_init;
 #endif
 
   // Define swig commands.