Web Embeddable Common Lisp

    term = new Terminal({
        theme: theme,
        fontSize: 14,
    });
    term.loadAddon(fito);
    term.open(node);
    fito.fit();
    
    return term;
}

const ostr_nl = '\r\n';
const ostr_style_non = '\x1B[0m';
const ostr_style_err = '\x1B[1;3;31m';

#include <stdio.h>
#include <emscripten.h>
#include <ecl/ecl.h>
















EM_ASYNC_JS(char *, js_read_inner, (), {
    return new Promise(resolve => read_promise =
                       function(cmd) {
                         c_cmd = stringToNewUTF8(cmd);
                         read_promise = null;
                         read_promise_var = null;
                         return resolve(c_cmd);
                       });
  });

cl_object js_read() {
  char *result = js_read_inner();
  return ecl_cstring_to_base_string_or_nil(result);
}

EM_JS(char *, js_text_inner, (const char *element_id), {
    id = Module.UTF8ToString(element_id);
    result = document.getElementById(id).textContent;
    return stringToNewUTF8(result);
  });

cl_object js_text(cl_object id) {
  const char * elt_id= ecl_base_string_pointer_safe
    (ecl_null_terminated_base_string(id));
  char *result = js_text_inner(elt_id);
  return ecl_cstring_to_base_string_or_nil(result);
}

cl_object js_eval(cl_object js_str) {
  const char *str = ecl_base_string_pointer_safe
    (ecl_null_terminated_base_string(js_str));
  emscripten_run_script(str);
  return ECL_NIL;
}

  ecl_def_c_function(aux, js_yield, 0);

  aux = ecl_make_symbol("JS-EVAL", "CL-USER");
  ecl_def_c_function(aux, js_eval, 1);

  aux = ecl_make_symbol("JS-READ", "CL-USER");
  ecl_def_c_function(aux, js_read, 0);

  aux = ecl_make_symbol("JS-TEXT", "CL-USER");
  ecl_def_c_function(aux, js_text, 1);
}

void wecl_exit() {
  cl_shutdown();
}

void wecl_test() {

  (case ch
    (#\newline "\\n")
    (#\'       "\\'")
    (#\`       "\\`")
    (#\\       "\\\\")
    (otherwise (string ch))))

(defun print-file (file)
  (with-open-file (input file)
    (format t "-- ~a~%" file)
    (loop for idx from 0
          for line = (read-line input nil)
          while line do
            (format t "~4,'0d: ~a~%" idx line)
            (js-yield))
    (format t "++ ~a~%" file)))

(defun read-file-to-string (file)
  (with-output-to-string (output)
    (with-open-file (input file)
      (loop for line = (read-line input nil)
            while line do
              (write-string line output)))))

(defun read-file-to-js-string (file)
  (with-output-to-string (output)
    (with-open-file (input file)
      (loop for line = (read-line input nil)
            while line do
              (loop for ch across line do
                (write-string (sanitize ch) output))

    (if (probe-file file)
        (prog1 t
          (let ((string (read-file-to-js-string file)))
            (js-eval* "shadow_dom.get('code').textContent=`~a`;" string)))
        (prog1 t
          (js-eval* "fetch_file(`~a`);" file)))))

(defun invoke-code-buffer (&optional (buffer-id "code"))

  (with-open-file (stream "code-buffer.lisp" :direction :output)
    (write-string (js-text buffer-id) stream))
  (compile-file "code-buffer.lisp" :load t))

#+(or) ;; not yet (static build? ship fasl? c.f dlopen)
(progn
  (require "ASDF")
  (print (asdf:asdf-version)))



(defun create-world ()
  (let ((graft (import-sheet "body" "body" "graft"))
        (stdo (import-sheet "div" "" "ostr"))
        (repl (import-sheet "div" "" "repl"))
        (code (open-buffer "code"))
        (draw (open-canvas "draw")))))

(defvar *js-initialized-p* nil)

(defun js-init ()
  (setf *standard-output* *ostr-stream*
        *standard-input*  *ostr-stream*
        *error-output*    *ostr-stream*
        *query-io*        *repl-stream*
        *debug-io*        *repl-stream*
        *terminal-io*     *repl-stream*)
  (ext:install-bytecodes-compiler)
  (pushnew #'update-code-buffer ext:*ed-functions*)
  (clear-output *repl-stream*)
  (create-world)
  ;; go!
  (repl))

#+wasm32
(unless *js-initialized-p*
  (setf *js-initialized-p* t)
  (js-init))

    echo "Building..."
    cp wecl.c wecl.lisp wasm-ecl/
    pushd wasm-ecl
    emcc -O2 \
         -sASYNCIFY -sASYNCIFY_STACK_SIZE=1048576 \
         -sASYNCIFY_IMPORTS=[cl_eval,js_test,js_read] \
         -sSTACK_SIZE=1048576 \
         -sINITIAL_MEMORY=67108864 \
         -sERROR_ON_UNDEFINED_SYMBOLS=0 \
         -sEXPORTED_RUNTIME_METHODS=ccall,cwrap,stringToNewUTF8,UTF8ToString \
         -sEXPORTED_FUNCTIONS=_wecl_brrt \
         --embed-file "wecl.lisp" \
         libecl{,gc,gmp}.a wecl.c -I./ -o wecl.js
    popd
    cp wasm-ecl/libecl{,gc,gmp}.a wasm-ecl/wecl.js wasm-ecl/wecl.wasm .
}