add lexical binding cookie to lisp/helper.el (#623)

CMUCL was published as .tar.bz2 up to 21e and switched to .tar.xz with
21f, but the installer always asked for .tar.bz2.  Since it picks the
newest release when no version is given, `ros install cmu-bin` now
always 404s:

  Downloading https://common-lisp.net/project/cmucl/downloads/release/21f/cmucl-21f-x86-linux.tar.bz2
  Downloading archive:...:NG
  bzip2: Can't open input file .../cmucl-21f-x86-linux.tar.bz2
  tar: This does not look like a tar archive
  Error: unable to use 'cmu-bin'

Look the file up in the release directory instead of assuming, the same
listing cmu-bin-get-version already parses, and keep .tar.bz2 as the
fallback when the listing can't be read.  extract() already handles .xz,
so nothing else needs to change.

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

.github/workflows/test.yml

@@ -21,9 +21,16 @@ jobs:
          - ecl
          - clisp
          - ccl-bin
-         - sbcl/1.4.0
+         - sbcl/2.4.0
          - ccl32
         experimental: [false]
+        exclude:
+          - lisp: ccl-bin
+            os: macos-latest
+          - lisp: ccl32
+            os: macos-latest
+          - lisp: cmu-bin/2019-06
+            os: macos-latest
         include:
           - lisp: mkcl
             os: macos-latest
@@ -64,5 +71,5 @@ jobs:
           ros version=t run
           ros install prove
           run-prove roswell-test.asd 2>&1
-          ros -q run && [`ros -q run 2>&1` == ""]
+          ros -q run && [ "$(ros -q run 2>&1)" = "" ]
           ros config

Makefile.am

@@ -77,7 +77,8 @@ LISPS = helper.el \
 	install+7zip.lisp install-abcl-bin.lisp install-allegro.lisp \
 	install-ccl-bin.lisp install-clasp-bin.lisp install-clasp.lisp \
 	install-clisp.lisp install-clisp-head.lisp \
-	install-cmu-bin.lisp install-ecl.lisp install-quicklisp.lisp \
+	install-cmu-bin.lisp install-dotcl-bin.lisp install-ecl.lisp \
+	install-quicklisp.lisp \
 	install-sbcl-bin.lisp install-sbcl.lisp install-sbcl-source.lisp \
 	install-sbcl-head.lisp \
 	install-slime.lisp install-sly.lisp \

lisp/dump-sbcl.lisp

@@ -126,10 +126,14 @@ IR1 (deftransform), IR2 (VOP) information in the infodb."
                  (setf (sb-impl::package-%shadowing-symbols package) nil)
                  (format t ".")
                  (setf (sb-impl::package-internal-symbols package)
-                       (sb-impl::make-package-hashtable 0))
+                       (if (fboundp 'sb-impl::make-symbol-table)
+                           (sb-impl::make-symbol-table 0)
+                           (sb-impl::make-package-hashtable 0)))
                  (format t ".")
                  (setf (sb-impl::package-external-symbols package)
-                       (sb-impl::make-package-hashtable 0))
+                       (if (fboundp 'sb-impl::make-symbol-table)
+                           (sb-impl::make-symbol-table 0)
+                           (sb-impl::make-package-hashtable 0)))
                  (format t ".")
                  (setf (sb-impl::package-tables package) #())
                  (format t ".")

lisp/helper.el

@@ -1,3 +1,4 @@
+;; -*- lexical-binding: nil; -*-
 (defun roswell-configdir ()
   (substring (shell-command-to-string "ros roswell-internal-use version confdir") 0 -1))
 

lisp/init.lisp

@@ -160,7 +160,8 @@ have the latest asdf, and this file has a workaround for this.
                    (ext:run-shell-command (format nil "~{~A~^ ~}" args))))))
 
 (defun exec (args)
-  #+(and unix sbcl)
+  #+(and unix sbcl
+         (not haiku))
   (execvp (first args) args)
   #+(and unix ccl)
   (ignore-errors
@@ -174,8 +175,8 @@ have the latest asdf, and this file has a workaround for this.
 
   (cond
     (is-quicklisp-already-available
-     (unless (equal (opt "quicklisp")
-                    (namestring (symbol-value (read-from-string "ql:*quicklisp-home*"))))
+     (unless (equal (ignore-errors (truename (pathname (opt "quicklisp"))))
+                    (ignore-errors (truename (symbol-value (read-from-string "ql:*quicklisp-home*")))))
        (setf *local-project-directories*
              (copy-list
               (symbol-value (read-from-string "ql:*local-project-directories*")))))

lisp/install-cmu-bin.lisp

@@ -21,11 +21,31 @@
   (or (cdr (assoc (uname-m) *cmu-uname-m-alist* :test 'equal))
       (uname-m)))
 
+(defun cmu-bin-directory-uri (version)
+  (format nil "~@{~A~}" (cmu-bin-uri) (if (find #\- version) "snapshots/" "release/")
+          (substitute #\/ #\- version) "/"))
+
+(defun cmu-bin-archive-name (version extra)
+  (format nil "~@{~A~}" "cmucl-" version "-" (cmu-uname-m) "-" (uname) (if extra ".extra" "")))
+
+(defun cmu-bin-archive-type (version)
+  "CMUCL was published as .tar.bz2 up to 21e and as .tar.xz from 21f on,
+so ask the download directory which one it has for VERSION."
+  (let ((file (merge-pathnames (format nil "tmp/cmu-bin-~A.html" version) (homedir)))
+        (name (cmu-bin-archive-name version nil)))
+    (or (ignore-errors
+         (download (cmu-bin-directory-uri version) file :interval (* 60 60))
+         (loop for link in (get-elements-by-tag-name (plump:parse file) "a")
+               for href = (plump:get-attribute link "href")
+               thereis (and href
+                            (find-if (lambda (type)
+                                       (equal href (format nil "~A~A" name type)))
+                                     '(".tar.xz" ".tar.bz2")))))
+        ".tar.bz2")))
+
 (defun cmu-bin-archive-uri (version extra)
-  (let ((uname (uname))
-        (cmu-uname-m (cmu-uname-m)))
-    (format nil "~@{~A~}" (cmu-bin-uri) (if (find #\- version) "snapshots/" "release/")
-            (substitute #\/ #\- version) "/cmucl-" version "-" cmu-uname-m "-" uname (if extra ".extra" "") ".tar.bz2")))
+  (format nil "~@{~A~}" (cmu-bin-directory-uri version)
+          (cmu-bin-archive-name version extra) (cmu-bin-archive-type version)))
 
 (defun cmu-bin-argv-parse (argv)
   (format *error-output* "~&Installing cmu-bin/~A...~%" (getf argv :version))

lisp/install-dotcl-bin.lisp

@@ -0,0 +1,95 @@
+(roswell:include "util-install")
+(defpackage :roswell.install.dotcl-bin
+  (:use :cl :roswell.install :roswell.util :roswell.locations))
+(in-package :roswell.install.dotcl-bin)
+
+(defun dotcl-bin-impl ()
+  (merge-pathnames (format nil "impls/~A/~A/dotcl-bin/" (uname-m) (uname)) (homedir)))
+
+(defun dotcl-bin-rid ()
+  (let* ((arch (uname-m))
+         (os (uname))
+         (arch-key (cond ((equal arch "x86-64") "x64")
+                         ((equal arch "arm64") "arm64")
+                         (t (error "dotcl-bin: unsupported arch ~A" arch))))
+         (os-key (cond ((equal os "linux") "linux")
+                       ((equal os "darwin") "osx")
+                       ((equal os "windows") "win")
+                       (t (error "dotcl-bin: unsupported os ~A" os)))))
+    (format nil "~A-~A" os-key arch-key)))
+
+(defvar *dotcl-bin-version-cache* nil)
+
+(defun dotcl-bin-get-version ()
+  (or *dotcl-bin-version-cache*
+      (setf *dotcl-bin-version-cache*
+            (let ((file (merge-pathnames "tmp/dotcl-bin.json" (homedir))))
+              (format *error-output* "Checking version to install....~%")
+              (download "https://api.github.com/repos/dotcl/dotcl/releases" file)
+              (with-open-file (in file)
+                (loop for line = (read-line in nil nil) while line
+                      for pos = (search "\"tag_name\"" line)
+                      when pos
+                      collect (let* ((q1 (position #\" line :start (+ pos 11)))
+                                     (q2 (and q1 (position #\" line :start (1+ q1)))))
+                                (when (and q1 q2)
+                                  (let ((tag (subseq line (1+ q1) q2)))
+                                    (if (and (plusp (length tag)) (char= (aref tag 0) #\v))
+                                        (subseq tag 1)
+                                        tag))))))))))
+
+(defun dotcl-bin-argv-parse (argv)
+  (set-opt "prefix" (dotcl-bin-impl))
+  (cons t argv))
+
+(defun dotcl-bin-download (argv)
+  (let ((rid (dotcl-bin-rid))
+        (ver (version argv)))
+    (set-opt "as" ver)
+    (set-opt "download.uri"
+             (format nil "https://github.com/dotcl/dotcl/releases/download/v~A/dotcl-~A-~A.tar.bz2"
+                     ver rid ver))
+    (set-opt "download.archive"
+             (let ((pos (position #\/ (opt "download.uri") :from-end t)))
+               (when pos
+                 (merge-pathnames (format nil "archives/~A"
+                                          (subseq (opt "download.uri") (1+ pos)))
+                                  (homedir)))))
+    `((,(opt "download.archive") ,(opt "download.uri")))))
+
+(defun dotcl-bin-expand (argv)
+  (format t "~%Extracting archive:~A~%" (opt "download.archive"))
+  (let ((dest (merge-pathnames (format nil "~A/" (opt "as")) (dotcl-bin-impl))))
+    (when (probe-file dest)
+      (uiop/filesystem:delete-directory-tree dest :validate t))
+    (ensure-directories-exist dest)
+    (expand (opt "download.archive") dest)
+    #-os-windows
+    (let ((apphost (merge-pathnames "runtime" dest)))
+      (when (probe-file apphost)
+        (uiop:run-program (list "chmod" "+x" (namestring apphost))
+                          :ignore-error-status t))))
+  (cons t argv))
+
+(defun dotcl-bin-script (argv)
+  (let* ((dotnet (which "dotnet"))
+         (dir (merge-pathnames (format nil "~A/" (opt "as")) (dotcl-bin-impl))))
+    (unless dotnet
+      (format *error-output* "Error: 'dotnet' (.NET SDK 10+) was not found in PATH.~%")
+      (format *error-output* "       Install .NET SDK 10 from https://dotnet.microsoft.com/download~%")
+      (format *error-output* "       'ros use dotcl-bin' will fail without dotnet.~%")
+      (roswell:quit 1))
+    (install-script
+     (merge-pathnames "dotcl" dir)
+     (format nil "exec \"~Aruntime\" \"$@\"" dir))
+    (cons t argv)))
+
+(defun dotcl-bin (type)
+  (case type
+    (:install `(,(decide-version 'dotcl-bin-get-version)
+                dotcl-bin-argv-parse
+                ,(decide-download 'dotcl-bin-download)
+                dotcl-bin-expand
+                dotcl-bin-script
+                setup))
+    (:list 'dotcl-bin-get-version)))

lisp/locations.lisp

@@ -54,7 +54,7 @@
 
 (export
  (defvar *allegro-agreement-uri*
-   '(#+darwin ("11.0express" . "https://franz.com/ftp/pub/legal/ACL-Express-20170301.pdf")
+   '(("11.0express" . "https://franz.com/ftp/pub/legal/ACL-Express-20170301.pdf")
      ("10.1express" . #1="https://franz.com/ftp/pub/legal/ACL-Express-20170301.pdf")
      ("100express"  . #1#)
      ("101b"        . "http://franz.com/products/licensing/FSLA10.1.beta.pdf"))))

lisp/update.ros

@@ -26,10 +26,17 @@ exec ros -Q -m roswell -N roswell -- $0 "$@"
        ;; update systems
        (dolist (alias argv)
          (loop
-            with path = (ignore-errors
-                          (make-pathname
-                           :type nil :name nil
-                           :defaults (asdf:system-source-file (asdf:find-system alias))))
+            with path = (or
+                         (and (find #\/ alias)
+                              (let ((dir (merge-pathnames
+                                          (format nil "local-projects/~A/" alias)
+                                          (roswell.util:homedir))))
+                                (when (probe-file (merge-pathnames ".git/" dir))
+                                  dir)))
+                         (ignore-errors
+                           (make-pathname
+                            :type nil :name nil
+                            :defaults (asdf:system-source-file (asdf:find-system alias)))))
             for f in *update-functions*
             for r = (and path (funcall f path))
             when r do (roswell:roswell `("install" ,alias))

scripts/install-for-ci.sh

@@ -1,7 +1,7 @@
 #!/bin/sh
 set -e
 
-ROSWELL_RELEASE_VERSION=24.10.115
+ROSWELL_RELEASE_VERSION=26.02.116
 ROSWELL_TARBALL_PATH=$HOME/roswell.tar.gz
 ROSWELL_DIR=$HOME/.roswell
 ROSWELL_REPO=${ROSWELL_REPO:-https://github.com/roswell/roswell}
@@ -165,7 +165,7 @@ install_roswell_bin () {
             GNUMAKE=/usr/local/bin/gmake
             apt_unless_installed roswell
         elif [ `uname` = "Darwin" ] && [ $ROSWELL_BRANCH = release ]; then
-            apt_unless_installed roswell
+            brew upgrade roswell 2>/dev/null || brew install roswell
         fi
     fi
 }
@@ -208,8 +208,6 @@ install_sbcl_bin () {
 install_lisp_dependency () {
     case "$USE_LISP" in
         alisp|allegro)
-	      apt_unless_installed libc6-i386
-          apt_unless_installed gcc-multilib
           USE_LISP=allegro
           ;;
         cmu|cmucl|cmu-bin)
@@ -227,6 +225,13 @@ install_lisp_dependency () {
           apt_unless_installed gcc-multilib
           ros config set ccl.bit 32
           ;;
+        sbcl/*)
+          if [ "$(uname)" = "Darwin" ]; then
+              brew install zstd 2>/dev/null || true
+          else
+              apt_unless_installed libzstd-dev
+          fi
+          ;;
         # 'sbcl-bin' is the default
         "")
           USE_LISP=sbcl-bin

scripts/release.ros

@@ -30,7 +30,7 @@ exec ros -Q -L sbcl-bin -- $0 "$@"
         (d (multiple-value-list(decode-universal-time (get-universal-time)))))
     (setf (first version) (- (nth 5 d) 2000)
           (second version) (nth 4 d)
-          (fourth version) (1+ (fourth version)))
+          (first (last version)) (1+ (first (last version))))
     (format nil "~{~2,'0d~^.~}" version)))
 
 (defun edit-file (path match replace version &key test)
@@ -179,7 +179,7 @@ exec ros -Q -L sbcl-bin -- $0 "$@"
 
 (defun main (subcmd &rest argv)
   (declare (ignorable argv))
-  (let ((subcmd (find subcmd '(prepare release release-push changelog release-ci)
+  (let ((subcmd (find subcmd '(prepare release-commit release-push changelog release-ci)
                       :test 'equal :key 'string-downcase)))
     (when subcmd
       (funcall subcmd argv))))

src/Makefile.am

@@ -32,7 +32,7 @@ ros_SOURCES = main.c opt.c download.c download_windows.c archive.c archive_windo
 	cmd-internal.c cmd-script.c \
 	cmd-run.c cmd-run-sbcl.c cmd-run-ccl.c cmd-run-clasp.c cmd-run-clisp.c cmd-run-ecl.c \
 	cmd-run-mkcl.c cmd-run-abcl.c cmd-run-cmu.c cmd-run-acl.c cmd-run-lispworks.c \
-	cmd-run-npt.c \
+	cmd-run-npt.c cmd-run-dotcl.c \
 	cmd-install.c install-sbcl-bin.c install-sbcl-bin_windows.c
 
 if WITH_WIN_ICON

src/cmd-run-dotcl.c

@@ -0,0 +1,45 @@
+#include "opt.h"
+
+char** cmd_run_dotcl(int argc,char** argv,struct sub_command* cmd) {
+  char* home=configdir();
+  char* arch=uname_m();
+  char* os=uname_s();
+  char* impl=(char*)cmd->name;
+  char* version=(char*)cmd->short_name;
+  /*[apphost binary] --eval init.lisp --eval (ros:run '(...)) [repl] */
+  int i;
+  char* impl_path=impldir(arch,os,impl, version);
+  char* help=get_opt("help",0);
+  char* script=get_opt("script",0);
+  char* program=get_opt("program",0);
+  char* dotcl_version=get_opt("version",0);
+  LVal ret=0;
+
+  s(arch),s(os);
+
+  ret=conss(cat(home,impl_path,DIRSEP,"runtime",EXE_EXTENTION,NULL),ret);
+
+  if(dotcl_version) {
+    ret=conss(q("--eval"),ret);
+    ret=conss(q("(progn (format t \"~A ~A~%\" (lisp-implementation-type) (lisp-implementation-version)) (dotcl:quit))"),ret);
+  }
+  ret=conss(q("--eval"),ret);
+  ret=conss(s_cat(q("(progn #-ros.init(cl:load \""),s_escape_string(lispdir()),q("init.lisp"),q("\"))"),NULL),ret);
+  ret=conss(q("--eval"),ret);
+  ret=conss(s_cat(q("(ros:run '("),q(program?program:""),
+                  script?cat("(:script ",script,")","(:quit ())",NULL):q(""),
+                  q("))"),NULL),ret);
+
+  /* dotcl exits after --eval/--load by default; for interactive (no script)
+     append the `repl` subcommand to keep the process alive. */
+  if(!script) {
+    ret=conss(q("repl"),ret);
+  }
+
+  for(i=1;i<argc;++i)
+    ret=conss(q(argv[i]),ret);
+
+  s(impl_path);
+  cond_printf(1,"\nhelp=%s script=%s\n",help?"t":"nil",script?script:"nil");
+  return stringlist_array(nreverse(ret));
+}

src/cmd-run.c

@@ -26,6 +26,8 @@ struct run_impl_t impls_to_run[]={
   {"lispworks",&cmd_run_lispworks},
   {"mkcl",&cmd_run_mkcl},
   {"npt",&cmd_run_npt},
+  {"dotcl",&cmd_run_dotcl},
+  {"dotcl-bin",&cmd_run_dotcl},
 };
 
 struct proc_opt run;

src/cmd-run.h

@@ -24,6 +24,7 @@ extern char** cmd_run_acl(int argc,char** argv,struct sub_command* cmd);
 extern char** cmd_run_lispworks(int argc,char** argv,struct sub_command* cmd);
 extern char** cmd_run_mkcl(int argc,char** argv,struct sub_command* cmd);
 extern char** cmd_run_npt(int argc,char** argv,struct sub_command* cmd);
+extern char** cmd_run_dotcl(int argc,char** argv,struct sub_command* cmd);
 extern struct proc_opt* register_runtime_options(struct proc_opt* cmd);
 int setup(char* target,char* env,char* impl);
 #define SETUP_SYSTEM(sys,msg) {\

t/ros.lisp

@@ -86,7 +86,7 @@
 (! "ros list")
 (! "ros list installed")
 (! "ros list dump")
-(! "ros swank install")
+(! "ros install slime")
 (! (format nil "ros help install ~A" (ros:opt "default.lisp")))
 
 #+sbcl