Merge pull request #596 from jscl-project/bootstrap

Bootstrap JSCL

Author: davazp

.github/workflows/deploy-preview.yml

@@ -27,7 +27,10 @@ jobs:
     - name: Install SBCL
       run: sudo apt-get install sbcl
 
-    - name: Build JSCL
+    # We publish the SBCL-built version until the bootstrap pipeline
+    # is more mature. Once bootstrap is stable, we can switch to
+    # ./bootstrap.sh to publish the self-hosted build.
+    - name: Build JSCL with SBCL
       run: ./make.sh
 
     - name: Deploy preview to Netlify

.github/workflows/pull-request.yml

@@ -26,9 +26,14 @@ jobs:
     - name: Install SBCL
       run: sudo apt-get install sbcl
 
-    - name: Build JSCL
-      run: ./make.sh
+    - name: Bootstrap JSCL
+      run: ./bootstrap.sh
 
-    - name: Run tests
-      run: ./run-tests.sh
+    - name: Run tests (SBCL)
+      run: ./run-tests.sh --sbcl
 
+    - name: Run tests (Stage 0)
+      run: ./run-tests.sh --jscl=out/jscl-node.js
+
+    - name: Run tests (Stage 1)
+      run: ./run-tests.sh --jscl=dist/jscl-node.js

.github/workflows/release-latest.yml

@@ -20,13 +20,16 @@ jobs:
       - name: Install SBCL
         run: sudo apt-get install sbcl
 
-      - name: Build
-        run: npm run build
+      # We publish the SBCL-built version until the bootstrap pipeline
+      # is more mature. Once bootstrap is stable, we can switch to
+      # ./bootstrap.sh to publish the self-hosted build.
+      - name: Build JSCL with SBCL
+        run: ./make.sh
         env:
           JSCL_RELEASE: true
 
       - name: Run tests
-        run: npm test
+        run: ./run-tests.sh
 
       - name: Deploy latest version
         uses: JamesIves/github-pages-deploy-action@v4

.github/workflows/release-npm.yml

@@ -25,13 +25,16 @@ jobs:
       - name: Install SBCL
         run: sudo apt-get install sbcl
 
-      - name: Build
-        run: npm run build
+      # We publish the SBCL-built version until the bootstrap pipeline
+      # is more mature. Once bootstrap is stable, we can switch to
+      # ./bootstrap.sh to publish the self-hosted build.
+      - name: Build JSCL with SBCL
+        run: ./make.sh
         env:
           JSCL_RELEASE: true
 
       - name: Run tests
-        run: npm test
+        run: ./run-tests.sh
 
       - name: Publish to npm
         run: npm publish

.gitignore

@@ -6,7 +6,6 @@
 *.lib
 \#*
 jscl.js
-tests.js
 .tmp/
 
 /repl-node.js
@@ -15,3 +14,6 @@ tests.js
 /node_modules/
 /.jscl_test/
 /dist/
+/out/
+
+tests/**/*.lisp.js

HACKING.org

@@ -2,7 +2,7 @@
 ** Newbie guide
     - Load slime from the root directory.
     - C-c C-l jscl.lisp  to load the whole project
-    - =(jscl:bootstrap)= will generate jscl.js
+    - =(jscl-xc:bootstrap "out/" "jscl")= will generate out/jscl.js
     - Add tests
     - Open tests.html in your browser to see your failed tests
 ** Code organization, style, etc.
@@ -16,7 +16,7 @@
 ** Hacking the compiler
 *** Interactive development
     - Load slime and bootstrap JSCL as explained in the newbie guide.
-    - Work in package JSCL with =(in-package #:jscl)=.
+    - Work in package JSCL-XC with =(in-package #:jscl-xc)=.
     - Use the =compile-toplevel= function to prepare the JavaSript code
       associated to a S-expression SEXP, compiled as a toplevel form.
     - Use the =process-toplevel= function to prepare the JavaScript
@@ -25,10 +25,10 @@
 
 
 #+BEGIN_EXAMPLE
-JSCL> (process-toplevel '(+ 1 2))
+JSCL-XC> (process-toplevel '(+ 1 2))
 (PROGN (SELFCALL (PROGN) (RETURN (+ 1 2))))
 
-JSCL> (compile-toplevel '(+ 1 2))
+JSCL-XC> (compile-toplevel '(+ 1 2))
 "(function(){return 1+2;
 })();
 "
@@ -49,7 +49,7 @@ the =*js-output*= output channel, which can be set to =t= to target
 stdout. For instance
 
 #+BEGIN_EXAMPLE
-JSCL> (js '(+ 1 2))
+JSCL-XC> (js '(+ 1 2))
 1+2;
 #+END_EXAMPLE
 
@@ -58,21 +58,21 @@ calls and =named-function= to distinguish function expressions
 featuring a function name.
 
 #+BEGIN_EXAMPLE
-JSCL> (js '(call (property |console| "log") "A message."))
+JSCL-XC> (js '(call (property |console| "log") "A message."))
 console['log']('A message.');
 
-JSCL> (js '(call (get |console| |log|) "A message."))
+JSCL-XC> (js '(call (get |console| |log|) "A message."))
 console.log('A message.');
 
-JSCL> (js '(call (get |console| "log") "A message."))
+JSCL-XC> (js '(call (get |console| "log") "A message."))
 console.log('A message.');
 
 
-JSCL> (js '(function (a b) (return (+ a b))))
+JSCL-XC> (js '(function (a b) (return (+ a b))))
 (function(A,B){return A+B;
 });
 
-JSCL> (js '(named-function "add2" (a b) (return (+ a b))))
+JSCL-XC> (js '(named-function "add2" (a b) (return (+ a b))))
 (function add2(A,B){return A+B;
 });
 #+END_EXAMPLE
@@ -102,13 +102,13 @@ generate. Compiler macros should not be mistaken for host Common Lisp
 macros.
 
 #+BEGIN_EXAMPLE
-JSCL> (define-builtin mod (x y)
+JSCL-XC> (define-builtin mod (x y)
   `(selfcall
     (if (== ,y 0)
         (throw "Division by zero in mod"))
     (return (% ,x ,y))))
 
-JSCL> (with-compilation-environment (process-toplevel '(mod 7 2)))
+JSCL-XC> (with-compilation-environment (process-toplevel '(mod 7 2)))
 (PROGN
  (SELFCALL
   (IF (== 2 0)

README.md

@@ -29,16 +29,15 @@ If you want to hack JSCL, you will have to download the repository
 
     git clone https://github.com/jscl-project/jscl.git
 
-Run `npm install` under the `jscl` directory. Then *load* `jscl.lisp`
-in your Lisp, and call the build-all function to compile the
-implementation itself:
+Run `npm install` under the `jscl` directory, then run the build
+script:
 
-    (jscl:build-all)
+    ./make.sh
 
-It will generate a `jscl.js` file in the `jscl/dist` directory. Now
-you can open `dist/index.html` in your browser and use it. To use in Node,
-`node dist/jscl-node.js`; to use in Deno,
-`deno --allow-env --allow-read dist/jscl-deno.js`.
+It will generate `jscl.js` and the rest of the distribution files in
+the `jscl/dist` directory. Now you can open `dist/index.html` in your
+browser and use it. To use in Node, `node dist/jscl-node.js`; to use
+in Deno, `deno --allow-env --allow-read dist/jscl-deno.js`.
 
 
 ## Status

bootstrap.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+set -e
+
+BASE=$(dirname "$0")
+cd "$BASE"
+
+echo "=== Stage 0: SBCL compiles cross-compiler ===" >&2
+./make.sh --sbcl -o out/
+
+echo "=== Stage 1: Cross-compiler compiles JSCL ===" >&2
+./make.sh --jscl=out/jscl-node.js -o dist/
+
+echo "=== Build complete ===" >&2

deno/build.lisp

@@ -0,0 +1,8 @@
+;;; deno/build.lisp — Build the Deno REPL
+;;;
+;;; This file is loaded by jscl-node.js to compile the Deno REPL.
+
+(defun build-deno-repl (output-directory)
+  "Build Deno REPL into OUTPUT-DIRECTORY."
+  (jscl:compile-application (list "deno/repl.lisp")
+                            (concatenate 'string output-directory "jscl-deno.js")))

deno/repl.lisp

@@ -11,45 +11,47 @@
 ;; You should have received a copy of the GNU General Public License
 ;; along with JSCL.  If not, see <http://www.gnu.org/licenses/>.
 
-(/debug "loading deno/repl.lisp!")
+(defpackage :jscl/deno-repl (:use :cl :jscl/ffi))
+(in-package :jscl/deno-repl)
 
 (defvar *rl*)
 
 (defun start-repl ()
-  (welcome-message)
+  (jscl::welcome-message)
   (setq *rl* (#j:readline:createInterface #j:process:stdin #j:process:stdout))
   (let ((input-buffer (make-string-output-stream))
         (linecont-prompt nil))
     (flet ((set-prompt ()
-             (let ((name (package-name-for-prompt *package*)))
-               ((oget *rl* "setPrompt") (jsstring (format nil "~a> " name)))
+             (let ((prompt (jscl::get-repl-prompt)))
+               ((oget *rl* "setPrompt") (jsstring prompt))
                (setq linecont-prompt
-                     (concat (make-string (1+ (length name)) :initial-element #\.) " ")))))
+                     (concatenate 'string (make-string (1- (length prompt)) :initial-element #\.) " ")))))
       (set-prompt)
       ((oget *rl* "prompt"))
       ((oget *rl* "on") #j"line"
        (lambda (line)
          (write-line (clstring line) input-buffer)
-         (let ((input (stream-data input-buffer)))
-           (if (%sexpr-incomplete input)
+         (let ((input (jscl::stream-data input-buffer)))
+           (if (jscl::%sexpr-incomplete input)
                ((oget *rl* "setPrompt") (jsstring linecont-prompt))
                (progn
-                 (with-toplevel-eval ()
-                   (eval-interactive-input input))
-                 (setf (fill-pointer (stream-data input-buffer)) 0)
+                 (jscl::with-toplevel-eval ()
+                   (jscl::eval-interactive-input input))
+                 (setf (fill-pointer (jscl::stream-data input-buffer)) 0)
                  ;; Update prompt
                  (set-prompt))))
          ;; Continue
          ((oget *rl* "prompt")))))))
 
 (defun deno-init ()
   (setq *standard-output*
-        (make-stream
+        (jscl::make-stream
          :write-fn (lambda (string)
                      (#j:process:stdout:write (jsstring string))))
         *error-output* *standard-output*
-        *trace-output* *standard-output*)
-  (let ((args (mapcar #'clstring (vector-to-list (subseq #j:process:argv 2)))))
+        *trace-output* *standard-output*
+        *package* (find-package "CL-USER"))
+  (let ((args (mapcar #'clstring (jscl::vector-to-list (subseq #j:process:argv 2)))))
     (cond
       ((null args)
        (start-repl))