Compare commits
7 Commits
623529d3be
...
loops/ruby
| Author | SHA1 | Date | |
|---|---|---|---|
| fa3274c394 | |||
| 15eb133311 | |||
| 96019e9fe8 | |||
| 3316d402fd | |||
| fb72c4ab9c | |||
| e52c209c3d | |||
| 6a00df2609 |
@@ -2042,8 +2042,8 @@ PLATFORM_DOM_JS = """
|
||||
// If lambda takes 0 params, call without event arg (convenience for on-click handlers)
|
||||
var wrapped = isLambda(handler)
|
||||
? (lambdaParams(handler).length === 0
|
||||
? function(e) { try { var r = cekCall(handler, NIL); if (globalThis._driveAsync) globalThis._driveAsync(r); } catch(err) { console.error("[sx-ref] domListen handler error:", name, err); } }
|
||||
: function(e) { try { var r = cekCall(handler, [e]); if (globalThis._driveAsync) globalThis._driveAsync(r); } catch(err) { console.error("[sx-ref] domListen handler error:", name, err); } })
|
||||
? function(e) { try { cekCall(handler, NIL); } catch(err) { console.error("[sx-ref] domListen handler error:", name, err); } }
|
||||
: function(e) { try { cekCall(handler, [e]); } catch(err) { console.error("[sx-ref] domListen handler error:", name, err); } })
|
||||
: handler;
|
||||
if (name === "click") logInfo("domListen: click on <" + (el.tagName||"?").toLowerCase() + "> text=" + (el.textContent||"").substring(0,20) + " isLambda=" + isLambda(handler));
|
||||
var passiveEvents = { touchstart: 1, touchmove: 1, wheel: 1, scroll: 1 };
|
||||
|
||||
@@ -1892,34 +1892,8 @@ let handle_sx_harness_eval args =
|
||||
let file = args |> member "file" |> to_string_option in
|
||||
let setup_str = args |> member "setup" |> to_string_option in
|
||||
let files_json = try args |> member "files" with _ -> `Null in
|
||||
let host_stubs = match args |> member "host_stubs" with `Bool b -> b | _ -> false in
|
||||
let e = !env in
|
||||
let warnings = ref [] in
|
||||
(* Inject stub host primitives so files using host-get/host-new/etc. can load *)
|
||||
if host_stubs then begin
|
||||
let stubs = {|
|
||||
(define host-global (fn (&rest _) nil))
|
||||
(define host-get (fn (&rest _) nil))
|
||||
(define host-set! (fn (obj k v) v))
|
||||
(define host-call (fn (&rest _) nil))
|
||||
(define host-new (fn (&rest _) (dict)))
|
||||
(define host-callback (fn (f) f))
|
||||
(define host-typeof (fn (&rest _) "string"))
|
||||
(define hs-ref-eq (fn (a b) (identical? a b)))
|
||||
(define host-call-fn (fn (&rest _) nil))
|
||||
(define host-iter? (fn (&rest _) false))
|
||||
(define host-to-list (fn (&rest _) (list)))
|
||||
(define host-await (fn (&rest _) nil))
|
||||
(define host-new-function (fn (&rest _) nil))
|
||||
(define load-library! (fn (&rest _) false))
|
||||
|} in
|
||||
let stub_exprs = Sx_parser.parse_all stubs in
|
||||
List.iter (fun expr ->
|
||||
try ignore (Sx_ref.eval_expr expr (Env e))
|
||||
with exn ->
|
||||
warnings := Printf.sprintf "Stub warning: %s" (Printexc.to_string exn) :: !warnings
|
||||
) stub_exprs
|
||||
end;
|
||||
(* Collect all files to load *)
|
||||
let all_files = match files_json with
|
||||
| `List items ->
|
||||
@@ -3044,8 +3018,7 @@ let tool_definitions = `List [
|
||||
("mock", `Assoc [("type", `String "string"); ("description", `String "Optional mock platform overrides as SX dict, e.g. {:fetch (fn (url) {:status 200})}")]);
|
||||
("file", `Assoc [("type", `String "string"); ("description", `String "Optional .sx file to load for definitions")]);
|
||||
("files", `Assoc [("type", `String "array"); ("items", `Assoc [("type", `String "string")]); ("description", `String "Multiple .sx files to load in order")]);
|
||||
("setup", `Assoc [("type", `String "string"); ("description", `String "SX setup expression to run before main evaluation")]);
|
||||
("host_stubs", `Assoc [("type", `String "boolean"); ("description", `String "If true, inject nil-returning stubs for host-get/host-set!/host-call/host-new/etc. so files that use host primitives can load in the harness")])]
|
||||
("setup", `Assoc [("type", `String "string"); ("description", `String "SX setup expression to run before main evaluation")])]
|
||||
["expr"];
|
||||
tool "sx_nav" "Manage sx-docs navigation and articles. Modes: list (all nav items with status), check (validate consistency), add (create article + nav entry), delete (remove nav entry + page fn), move (move entry between sections, rewriting hrefs)."
|
||||
[("mode", `Assoc [("type", `String "string"); ("description", `String "Mode: list, check, add, delete, or move")]);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -19,7 +19,6 @@
|
||||
(define
|
||||
reserved
|
||||
(list
|
||||
(quote beingTold)
|
||||
(quote me)
|
||||
(quote it)
|
||||
(quote event)
|
||||
@@ -66,10 +65,7 @@
|
||||
(list (quote me))
|
||||
(list
|
||||
(quote let)
|
||||
(list
|
||||
(list (quote beingTold) (quote me))
|
||||
(list (quote it) nil)
|
||||
(list (quote event) nil))
|
||||
(list (list (quote it) nil) (list (quote event) nil))
|
||||
guarded))))))))))
|
||||
|
||||
;; ── Activate a single element ───────────────────────────────────
|
||||
@@ -77,77 +73,23 @@
|
||||
;; Marks the element to avoid double-activation.
|
||||
|
||||
(define
|
||||
hs-register-scripts!
|
||||
hs-activate!
|
||||
(fn
|
||||
()
|
||||
(for-each
|
||||
(fn
|
||||
(script)
|
||||
(when
|
||||
(not (dom-get-data script "hs-script-loaded"))
|
||||
(let
|
||||
((src (host-get script "innerHTML")))
|
||||
(when
|
||||
(and src (not (= src "")))
|
||||
(guard
|
||||
(_e (true nil))
|
||||
(eval-expr-cek (hs-to-sx-from-source src)))
|
||||
(dom-set-data script "hs-script-loaded" true)))))
|
||||
(hs-query-all "script[type=text/hyperscript]"))))
|
||||
(el)
|
||||
(let
|
||||
((src (dom-get-attr el "_")) (prev (dom-get-data el "hs-script")))
|
||||
(when
|
||||
(and src (not (= src prev)))
|
||||
(hs-log-event! "hyperscript:init")
|
||||
(dom-set-data el "hs-script" src)
|
||||
(dom-set-data el "hs-active" true)
|
||||
(dom-set-attr el "data-hyperscript-powered" "true")
|
||||
(let ((handler (hs-handler src))) (handler el))))))
|
||||
|
||||
;; ── Boot: scan entire document ──────────────────────────────────
|
||||
;; Called once at page load. Finds all elements with _ attribute,
|
||||
;; compiles their hyperscript, and activates them.
|
||||
|
||||
(define
|
||||
hs-scripting-disabled?
|
||||
(fn
|
||||
(el)
|
||||
(if
|
||||
(= el nil)
|
||||
false
|
||||
(if
|
||||
(dom-get-attr el "disable-scripting")
|
||||
true
|
||||
(hs-scripting-disabled? (dom-parent el))))))
|
||||
|
||||
;; ── Boot subtree: for dynamic content ───────────────────────────
|
||||
;; Called after HTMX swaps or dynamic DOM insertion.
|
||||
;; Only activates elements within the given root.
|
||||
|
||||
(define
|
||||
hs-activate!
|
||||
(fn
|
||||
(el)
|
||||
(do
|
||||
(hs-register-scripts!)
|
||||
(let
|
||||
((src (dom-get-attr el "_")) (prev (dom-get-data el "hs-script")))
|
||||
(when
|
||||
(and src (not (= src prev)) (not (hs-scripting-disabled? el)))
|
||||
(when
|
||||
(dom-dispatch el "hyperscript:before:init" nil)
|
||||
(hs-log-event! "hyperscript:init")
|
||||
(dom-set-data el "hs-script" src)
|
||||
(dom-set-data el "hs-active" true)
|
||||
(dom-set-attr el "data-hyperscript-powered" "true")
|
||||
(guard
|
||||
(_e (true nil))
|
||||
(let
|
||||
((handler (hs-handler src)))
|
||||
(let
|
||||
((el-type (dom-get-attr el "type"))
|
||||
(comp-name (dom-get-attr el "component")))
|
||||
(let
|
||||
((safe-handler (fn (e) (host-call-fn handler (list e)))))
|
||||
(if
|
||||
(= el-type "text/hyperscript-template")
|
||||
(for-each
|
||||
safe-handler
|
||||
(hs-query-all (or comp-name "")))
|
||||
(safe-handler el))))))
|
||||
(dom-dispatch el "hyperscript:after:init" nil)))))))
|
||||
|
||||
(define
|
||||
hs-deactivate!
|
||||
(fn
|
||||
@@ -159,6 +101,10 @@
|
||||
(dom-set-data el "hs-active" false)
|
||||
(dom-set-data el "hs-script" nil))))
|
||||
|
||||
;; ── Boot subtree: for dynamic content ───────────────────────────
|
||||
;; Called after HTMX swaps or dynamic DOM insertion.
|
||||
;; Only activates elements within the given root.
|
||||
|
||||
(define
|
||||
hs-boot!
|
||||
(fn
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -28,27 +28,6 @@
|
||||
|
||||
(define hs-ws? (fn (c) (or (= c " ") (= c "\t") (= c "\n") (= c "\r"))))
|
||||
|
||||
(define
|
||||
hs-hex-digit?
|
||||
(fn
|
||||
(c)
|
||||
(or
|
||||
(and (>= c "0") (<= c "9"))
|
||||
(and (>= c "a") (<= c "f"))
|
||||
(and (>= c "A") (<= c "F")))))
|
||||
|
||||
(define
|
||||
hs-hex-val
|
||||
(fn
|
||||
(c)
|
||||
(let
|
||||
((code (char-code c)))
|
||||
(cond
|
||||
((and (>= code 48) (<= code 57)) (- code 48))
|
||||
((and (>= code 65) (<= code 70)) (- code 55))
|
||||
((and (>= code 97) (<= code 102)) (- code 87))
|
||||
(true 0)))))
|
||||
|
||||
;; ── Keyword set ───────────────────────────────────────────────────
|
||||
|
||||
(define
|
||||
@@ -131,7 +110,6 @@
|
||||
"append"
|
||||
"settle"
|
||||
"transition"
|
||||
"view"
|
||||
"over"
|
||||
"closest"
|
||||
"next"
|
||||
@@ -209,8 +187,7 @@
|
||||
"using"
|
||||
"giving"
|
||||
"ask"
|
||||
"answer"
|
||||
"bind"))
|
||||
"answer"))
|
||||
|
||||
(define hs-keyword? (fn (word) (some (fn (k) (= k word)) hs-keywords)))
|
||||
|
||||
@@ -258,15 +235,10 @@
|
||||
read-number
|
||||
(fn
|
||||
(start)
|
||||
(define
|
||||
read-int
|
||||
(fn
|
||||
()
|
||||
(when
|
||||
(and (< pos src-len) (hs-digit? (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(read-int))))
|
||||
(read-int)
|
||||
(when
|
||||
(and (< pos src-len) (hs-digit? (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(read-number start))
|
||||
(when
|
||||
(and
|
||||
(< pos src-len)
|
||||
@@ -274,7 +246,15 @@
|
||||
(< (+ pos 1) src-len)
|
||||
(hs-digit? (hs-peek 1)))
|
||||
(hs-advance! 1)
|
||||
(read-int))
|
||||
(define
|
||||
read-frac
|
||||
(fn
|
||||
()
|
||||
(when
|
||||
(and (< pos src-len) (hs-digit? (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(read-frac))))
|
||||
(read-frac))
|
||||
(do
|
||||
(when
|
||||
(and
|
||||
@@ -292,7 +272,15 @@
|
||||
(< pos src-len)
|
||||
(or (= (hs-cur) "+") (= (hs-cur) "-")))
|
||||
(hs-advance! 1))
|
||||
(read-int))
|
||||
(define
|
||||
read-exp-digits
|
||||
(fn
|
||||
()
|
||||
(when
|
||||
(and (< pos src-len) (hs-digit? (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(read-exp-digits))))
|
||||
(read-exp-digits))
|
||||
(let
|
||||
((num-end pos))
|
||||
(when
|
||||
@@ -320,7 +308,7 @@
|
||||
()
|
||||
(cond
|
||||
(>= pos src-len)
|
||||
(error "Unterminated string")
|
||||
nil
|
||||
(= (hs-cur) "\\")
|
||||
(do
|
||||
(hs-advance! 1)
|
||||
@@ -330,47 +318,15 @@
|
||||
((ch (hs-cur)))
|
||||
(cond
|
||||
(= ch "n")
|
||||
(do (append! chars "\n") (hs-advance! 1))
|
||||
(append! chars "\n")
|
||||
(= ch "t")
|
||||
(do (append! chars "\t") (hs-advance! 1))
|
||||
(= ch "r")
|
||||
(do (append! chars "\r") (hs-advance! 1))
|
||||
(= ch "b")
|
||||
(do
|
||||
(append! chars (char-from-code 8))
|
||||
(hs-advance! 1))
|
||||
(= ch "f")
|
||||
(do
|
||||
(append! chars (char-from-code 12))
|
||||
(hs-advance! 1))
|
||||
(= ch "v")
|
||||
(do
|
||||
(append! chars (char-from-code 11))
|
||||
(hs-advance! 1))
|
||||
(append! chars "\t")
|
||||
(= ch "\\")
|
||||
(do (append! chars "\\") (hs-advance! 1))
|
||||
(append! chars "\\")
|
||||
(= ch quote-char)
|
||||
(do (append! chars quote-char) (hs-advance! 1))
|
||||
(= ch "x")
|
||||
(do
|
||||
(hs-advance! 1)
|
||||
(if
|
||||
(and
|
||||
(< (+ pos 1) src-len)
|
||||
(hs-hex-digit? (hs-cur))
|
||||
(hs-hex-digit? (hs-peek 1)))
|
||||
(let
|
||||
((d1 (hs-hex-val (hs-cur)))
|
||||
(d2 (hs-hex-val (hs-peek 1))))
|
||||
(append!
|
||||
chars
|
||||
(char-from-code (+ (* d1 16) d2)))
|
||||
(hs-advance! 2))
|
||||
(error "Invalid hexadecimal escape: \\x")))
|
||||
:else (do
|
||||
(append! chars "\\")
|
||||
(append! chars ch)
|
||||
(hs-advance! 1)))))
|
||||
(append! chars quote-char)
|
||||
:else (do (append! chars "\\") (append! chars ch)))
|
||||
(hs-advance! 1)))
|
||||
(loop))
|
||||
(= (hs-cur) quote-char)
|
||||
(hs-advance! 1)
|
||||
@@ -457,68 +413,27 @@
|
||||
read-class-name
|
||||
(fn
|
||||
(start)
|
||||
(define
|
||||
build-name
|
||||
(fn
|
||||
(acc depth)
|
||||
(cond
|
||||
((and (< pos src-len) (= (hs-cur) "\\") (< (+ pos 1) src-len))
|
||||
(do
|
||||
(hs-advance! 1)
|
||||
(let
|
||||
((c (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(build-name (str acc c) depth))))
|
||||
((and (< pos src-len) (= (hs-cur) "["))
|
||||
(do
|
||||
(let
|
||||
((c (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(build-name (str acc c) (+ depth 1)))))
|
||||
((and (< pos src-len) (= (hs-cur) "]"))
|
||||
(do
|
||||
(let
|
||||
((c (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(build-name
|
||||
(str acc c)
|
||||
(if (> depth 0) (- depth 1) 0)))))
|
||||
((and (< pos src-len) (> depth 0) (or (= (hs-cur) "(") (= (hs-cur) ")")))
|
||||
(do
|
||||
(let
|
||||
((c (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(build-name (str acc c) depth))))
|
||||
((and (< pos src-len) (or (hs-ident-char? (hs-cur)) (= (hs-cur) ":") (= (hs-cur) "&")))
|
||||
(do
|
||||
(let
|
||||
((c (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(build-name (str acc c) depth))))
|
||||
(true acc))))
|
||||
(build-name "" 0)))
|
||||
(when
|
||||
(and
|
||||
(< pos src-len)
|
||||
(or
|
||||
(hs-ident-char? (hs-cur))
|
||||
(= (hs-cur) ":")
|
||||
(= (hs-cur) "[")
|
||||
(= (hs-cur) "]")))
|
||||
(hs-advance! 1)
|
||||
(read-class-name start))
|
||||
(slice src start pos)))
|
||||
(define
|
||||
hs-emit!
|
||||
(fn
|
||||
(type value start)
|
||||
(let
|
||||
((tok (hs-make-token type value start))
|
||||
(end-pos
|
||||
(max pos (+ start (if (nil? value) 0 (len (str value)))))))
|
||||
(do
|
||||
(dict-set! tok "end" end-pos)
|
||||
(dict-set! tok "line" (len (split (slice src 0 start) "\n")))
|
||||
(append! tokens tok)))))
|
||||
(append! tokens (hs-make-token type value start))))
|
||||
(define
|
||||
scan!
|
||||
(fn
|
||||
()
|
||||
(let
|
||||
((ws-start pos))
|
||||
(skip-ws!)
|
||||
(when
|
||||
(and (> (len tokens) 0) (> pos ws-start))
|
||||
(hs-emit! "whitespace" (slice src ws-start pos) ws-start)))
|
||||
(skip-ws!)
|
||||
(when
|
||||
(< pos src-len)
|
||||
(let
|
||||
@@ -538,26 +453,10 @@
|
||||
(= (hs-peek 1) "#")
|
||||
(= (hs-peek 1) "[")
|
||||
(= (hs-peek 1) "*")
|
||||
(= (hs-peek 1) ":")
|
||||
(= (hs-peek 1) "$")))
|
||||
(= (hs-peek 1) ":")))
|
||||
(do (hs-emit! "selector" (read-selector) start) (scan!))
|
||||
(and (= ch ".") (< (+ pos 1) src-len) (= (hs-peek 1) "."))
|
||||
(do (hs-emit! "op" ".." start) (hs-advance! 2) (scan!))
|
||||
(and
|
||||
(= ch ".")
|
||||
(< (+ pos 1) src-len)
|
||||
(or
|
||||
(hs-letter? (hs-peek 1))
|
||||
(= (hs-peek 1) "-")
|
||||
(= (hs-peek 1) "_"))
|
||||
(> (len tokens) 0)
|
||||
(let
|
||||
((lt (dict-get (nth tokens (- (len tokens) 1)) :type)))
|
||||
(or
|
||||
(= lt "paren-close")
|
||||
(= lt "brace-close")
|
||||
(= lt "bracket-close"))))
|
||||
(do (hs-emit! "dot" "." start) (hs-advance! 1) (scan!))
|
||||
(and
|
||||
(= ch ".")
|
||||
(< (+ pos 1) src-len)
|
||||
@@ -569,18 +468,6 @@
|
||||
(hs-advance! 1)
|
||||
(hs-emit! "class" (read-class-name pos) start)
|
||||
(scan!))
|
||||
(and
|
||||
(= ch "#")
|
||||
(< (+ pos 1) src-len)
|
||||
(hs-ident-start? (hs-peek 1))
|
||||
(> (len tokens) 0)
|
||||
(let
|
||||
((lt (dict-get (nth tokens (- (len tokens) 1)) :type)))
|
||||
(or
|
||||
(= lt "paren-close")
|
||||
(= lt "brace-close")
|
||||
(= lt "bracket-close"))))
|
||||
(do (hs-emit! "op" "#" start) (hs-advance! 1) (scan!))
|
||||
(and
|
||||
(= ch "#")
|
||||
(< (+ pos 1) src-len)
|
||||
@@ -649,12 +536,10 @@
|
||||
(do
|
||||
(let
|
||||
((word (read-ident start)))
|
||||
(let
|
||||
((full-word (if (and (< pos src-len) (= (hs-cur) "'") (< (+ pos 1) src-len) (hs-letter? (hs-peek 1)) (not (and (= (hs-peek 1) "s") (or (>= (+ pos 2) src-len) (not (hs-ident-char? (hs-peek 2))))))) (do (hs-advance! 1) (str word "'" (read-ident pos))) word)))
|
||||
(hs-emit!
|
||||
(if (hs-keyword? full-word) "keyword" "ident")
|
||||
full-word
|
||||
start)))
|
||||
(hs-emit!
|
||||
(if (hs-keyword? word) "keyword" "ident")
|
||||
word
|
||||
start))
|
||||
(scan!))
|
||||
(and
|
||||
(or (= ch "=") (= ch "!") (= ch "<") (= ch ">"))
|
||||
@@ -735,82 +620,7 @@
|
||||
(do (hs-emit! "colon" ":" start) (hs-advance! 1) (scan!))
|
||||
(= ch "|")
|
||||
(do (hs-emit! "op" "|" start) (hs-advance! 1) (scan!))
|
||||
(= ch "&")
|
||||
(do (hs-emit! "op" "&" start) (hs-advance! 1) (scan!))
|
||||
(= ch "#")
|
||||
(do (hs-emit! "op" "#" start) (hs-advance! 1) (scan!))
|
||||
(= ch "?")
|
||||
(do (hs-emit! "op" "?" start) (hs-advance! 1) (scan!))
|
||||
(= ch ";")
|
||||
(do (hs-emit! "op" ";" start) (hs-advance! 1) (scan!))
|
||||
:else (do (hs-advance! 1) (scan!)))))))
|
||||
(scan!)
|
||||
(hs-emit! "eof" nil pos)
|
||||
tokens)))
|
||||
|
||||
;; ── Template-mode tokenizer (E37 API) ────────────────────────────────
|
||||
;; Used by hs-tokens-of when :template flag is set.
|
||||
;; Emits outer " chars as single STRING tokens; ${ ... } as $ { <inner-tokens> };
|
||||
;; inner content is tokenized with the regular hs-tokenize.
|
||||
|
||||
(define
|
||||
hs-tokenize-template
|
||||
(fn
|
||||
(src)
|
||||
(let
|
||||
((tokens (list)) (pos 0) (src-len (len src)))
|
||||
(define t-cur (fn () (if (< pos src-len) (nth src pos) nil)))
|
||||
(define t-peek (fn (n) (if (< (+ pos n) src-len) (nth src (+ pos n)) nil)))
|
||||
(define t-advance! (fn (n) (set! pos (+ pos n))))
|
||||
(define t-emit! (fn (type value) (append! tokens (hs-make-token type value pos))))
|
||||
(define
|
||||
scan-to-close!
|
||||
(fn
|
||||
(depth)
|
||||
(when
|
||||
(and (< pos src-len) (> depth 0))
|
||||
(cond
|
||||
(= (t-cur) "{")
|
||||
(do (t-advance! 1) (scan-to-close! (+ depth 1)))
|
||||
(= (t-cur) "}")
|
||||
(when (> (- depth 1) 0) (t-advance! 1) (scan-to-close! (- depth 1)))
|
||||
:else (do (t-advance! 1) (scan-to-close! depth))))))
|
||||
(define
|
||||
scan-template!
|
||||
(fn
|
||||
()
|
||||
(when
|
||||
(< pos src-len)
|
||||
(let
|
||||
((ch (t-cur)))
|
||||
(cond
|
||||
(= ch "\"")
|
||||
(do (t-emit! "string" "\"") (t-advance! 1) (scan-template!))
|
||||
(and (= ch "$") (= (t-peek 1) "{"))
|
||||
(do
|
||||
(t-emit! "op" "$")
|
||||
(t-advance! 1)
|
||||
(t-emit! "brace-open" "{")
|
||||
(t-advance! 1)
|
||||
(let
|
||||
((inner-start pos))
|
||||
(scan-to-close! 1)
|
||||
(let
|
||||
((inner-src (slice src inner-start pos))
|
||||
(inner-toks (hs-tokenize inner-src)))
|
||||
(for-each
|
||||
(fn (tok)
|
||||
(when (not (= (get tok "type") "eof"))
|
||||
(append! tokens tok)))
|
||||
inner-toks))
|
||||
(t-emit! "brace-close" "}")
|
||||
(when (< pos src-len) (t-advance! 1)))
|
||||
(scan-template!))
|
||||
(= ch "$")
|
||||
(do (t-emit! "op" "$") (t-advance! 1) (scan-template!))
|
||||
(hs-ws? ch)
|
||||
(do (t-advance! 1) (scan-template!))
|
||||
:else (do (t-advance! 1) (scan-template!)))))))
|
||||
(scan-template!)
|
||||
(t-emit! "eof" nil)
|
||||
tokens)))
|
||||
831
lib/ruby/parser.sx
Normal file
831
lib/ruby/parser.sx
Normal file
@@ -0,0 +1,831 @@
|
||||
;; Ruby parser: token list → AST.
|
||||
;; Entry: (rb-parse tokens) or (rb-parse-str src)
|
||||
;; AST nodes: dicts with :type plus type-specific fields.
|
||||
|
||||
(define rb-parse
|
||||
(fn (tokens)
|
||||
(let ((pos 0) (tok-count (len tokens)))
|
||||
|
||||
(define rb-p-cur
|
||||
(fn () (nth tokens pos)))
|
||||
(define rb-p-peek
|
||||
(fn (n)
|
||||
(if (< (+ pos n) tok-count)
|
||||
(nth tokens (+ pos n))
|
||||
{:type "eof" :value nil :line 0 :col 0})))
|
||||
(define rb-p-advance!
|
||||
(fn () (set! pos (+ pos 1))))
|
||||
(define rb-p-type
|
||||
(fn () (get (rb-p-cur) :type)))
|
||||
(define rb-p-val
|
||||
(fn () (get (rb-p-cur) :value)))
|
||||
(define rb-p-sep?
|
||||
(fn () (or (= (rb-p-type) "newline") (= (rb-p-type) "semi"))))
|
||||
(define rb-p-skip-seps!
|
||||
(fn ()
|
||||
(when (rb-p-sep?)
|
||||
(do (rb-p-advance!) (rb-p-skip-seps!)))))
|
||||
(define rb-p-skip-newlines!
|
||||
(fn ()
|
||||
(when (= (rb-p-type) "newline")
|
||||
(do (rb-p-advance!) (rb-p-skip-newlines!)))))
|
||||
(define rb-p-expect!
|
||||
(fn (type)
|
||||
(if (= (rb-p-type) type)
|
||||
(let ((tok (rb-p-cur)))
|
||||
(rb-p-advance!)
|
||||
tok)
|
||||
{:type "error"
|
||||
:msg (join "" (list "expected " type " got " (rb-p-type)))})))
|
||||
(define rb-p-expect-kw!
|
||||
(fn (kw)
|
||||
(when (and (= (rb-p-type) "keyword") (= (rb-p-val) kw))
|
||||
(rb-p-advance!))))
|
||||
|
||||
;; Block: do |params| body end or { |params| body }
|
||||
(define rb-p-parse-block-params
|
||||
(fn ()
|
||||
(if (= (rb-p-type) "pipe")
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(let ((params (list)))
|
||||
(define rb-p-bp-loop
|
||||
(fn ()
|
||||
(when (not (or (= (rb-p-type) "pipe") (= (rb-p-type) "eof")))
|
||||
(do
|
||||
(cond
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "**"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(append! params {:type "param-kwrest" :name (rb-p-val)})
|
||||
(rb-p-advance!)))
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "*"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(if (= (rb-p-type) "ident")
|
||||
(do
|
||||
(append! params {:type "param-rest" :name (rb-p-val)})
|
||||
(rb-p-advance!))
|
||||
(append! params {:type "param-rest" :name nil}))))
|
||||
(:else
|
||||
(do
|
||||
(append! params {:type "param-req" :name (rb-p-val)})
|
||||
(rb-p-advance!))))
|
||||
(when (= (rb-p-type) "comma") (rb-p-advance!))
|
||||
(rb-p-bp-loop)))))
|
||||
(rb-p-bp-loop)
|
||||
(rb-p-expect! "pipe")
|
||||
params))
|
||||
(list))))
|
||||
|
||||
(define rb-p-parse-block
|
||||
(fn ()
|
||||
(cond
|
||||
((and (= (rb-p-type) "keyword") (= (rb-p-val) "do"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(let ((params (rb-p-parse-block-params)))
|
||||
(rb-p-skip-seps!)
|
||||
(let ((body (rb-p-parse-stmts (list "end"))))
|
||||
(rb-p-expect-kw! "end")
|
||||
{:type "block" :params params :body body}))))
|
||||
((= (rb-p-type) "lbrace")
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(let ((params (rb-p-parse-block-params)))
|
||||
(rb-p-skip-seps!)
|
||||
(let ((body (rb-p-parse-stmts (list "rbrace"))))
|
||||
(rb-p-expect! "rbrace")
|
||||
{:type "block" :params params :body body}))))
|
||||
(:else nil))))
|
||||
|
||||
;; Method def params
|
||||
(define rb-p-parse-def-params
|
||||
(fn ()
|
||||
(let ((params (list)))
|
||||
(define rb-p-dp-one
|
||||
(fn ()
|
||||
(cond
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "&"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(append! params {:type "param-block" :name (rb-p-val)})
|
||||
(rb-p-advance!)))
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "**"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(append! params {:type "param-kwrest" :name (rb-p-val)})
|
||||
(rb-p-advance!)))
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "*"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(if (= (rb-p-type) "ident")
|
||||
(do
|
||||
(append! params {:type "param-rest" :name (rb-p-val)})
|
||||
(rb-p-advance!))
|
||||
(append! params {:type "param-rest" :name nil}))))
|
||||
((and (= (rb-p-type) "ident")
|
||||
(= (get (rb-p-peek 1) :type) "colon"))
|
||||
(do
|
||||
(let ((name (rb-p-val)))
|
||||
(rb-p-advance!)
|
||||
(rb-p-advance!)
|
||||
(if (or (rb-p-sep?) (= (rb-p-type) "comma")
|
||||
(= (rb-p-type) "rparen") (= (rb-p-type) "eof"))
|
||||
(append! params {:type "param-kw" :name name :default nil})
|
||||
(append! params {:type "param-kw" :name name
|
||||
:default (rb-p-parse-assign)})))))
|
||||
(:else
|
||||
(let ((name (rb-p-val)))
|
||||
(rb-p-advance!)
|
||||
(if (and (= (rb-p-type) "op") (= (rb-p-val) "="))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(append! params {:type "param-opt" :name name
|
||||
:default (rb-p-parse-assign)}))
|
||||
(append! params {:type "param-req" :name name})))))))
|
||||
(define rb-p-dp-loop
|
||||
(fn ()
|
||||
(when (not (or (= (rb-p-type) "rparen") (rb-p-sep?)
|
||||
(= (rb-p-type) "eof")))
|
||||
(do
|
||||
(rb-p-dp-one)
|
||||
(when (= (rb-p-type) "comma")
|
||||
(do (rb-p-advance!) (rb-p-skip-newlines!)))
|
||||
(rb-p-dp-loop)))))
|
||||
(rb-p-dp-loop)
|
||||
params)))
|
||||
|
||||
;; def [recv.] name [(params)] body end
|
||||
(define rb-p-parse-def
|
||||
(fn ()
|
||||
(rb-p-advance!)
|
||||
(let ((recv nil) (name nil))
|
||||
(cond
|
||||
((and (= (rb-p-type) "keyword") (= (rb-p-val) "self")
|
||||
(= (get (rb-p-peek 1) :type) "dot"))
|
||||
(do
|
||||
(set! recv {:type "self"})
|
||||
(rb-p-advance!)
|
||||
(rb-p-advance!)
|
||||
(set! name (rb-p-val))
|
||||
(rb-p-advance!)))
|
||||
((and (= (rb-p-type) "ident")
|
||||
(= (get (rb-p-peek 1) :type) "dot"))
|
||||
(do
|
||||
(set! recv {:type "lvar" :name (rb-p-val)})
|
||||
(rb-p-advance!)
|
||||
(rb-p-advance!)
|
||||
(set! name (rb-p-val))
|
||||
(rb-p-advance!)))
|
||||
(:else
|
||||
(do
|
||||
(set! name (rb-p-val))
|
||||
(rb-p-advance!))))
|
||||
(let ((params (list)))
|
||||
(cond
|
||||
((= (rb-p-type) "lparen")
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(rb-p-skip-newlines!)
|
||||
(set! params (rb-p-parse-def-params))
|
||||
(rb-p-expect! "rparen")))
|
||||
((not (or (rb-p-sep?) (= (rb-p-type) "eof")))
|
||||
(set! params (rb-p-parse-def-params)))
|
||||
(:else nil))
|
||||
(rb-p-skip-seps!)
|
||||
(let ((body (rb-p-parse-stmts (list "end"))))
|
||||
(rb-p-expect-kw! "end")
|
||||
{:type "method-def" :recv recv :name name
|
||||
:params params :body body})))))
|
||||
|
||||
;; class [<<obj | Name [<Super]] body end
|
||||
(define rb-p-parse-class
|
||||
(fn ()
|
||||
(rb-p-advance!)
|
||||
(if (and (= (rb-p-type) "op") (= (rb-p-val) "<<"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(let ((obj (rb-p-parse-primary)))
|
||||
(rb-p-skip-seps!)
|
||||
(let ((body (rb-p-parse-stmts (list "end"))))
|
||||
(rb-p-expect-kw! "end")
|
||||
{:type "sclass" :obj obj :body body})))
|
||||
(let ((name (rb-p-parse-const-path)))
|
||||
(let ((super nil))
|
||||
(when (and (= (rb-p-type) "op") (= (rb-p-val) "<"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(set! super (rb-p-parse-const-path))))
|
||||
(rb-p-skip-seps!)
|
||||
(let ((body (rb-p-parse-stmts (list "end"))))
|
||||
(rb-p-expect-kw! "end")
|
||||
{:type "class-def" :name name :super super :body body}))))))
|
||||
|
||||
;; module Name body end
|
||||
(define rb-p-parse-module
|
||||
(fn ()
|
||||
(rb-p-advance!)
|
||||
(let ((name (rb-p-parse-const-path)))
|
||||
(rb-p-skip-seps!)
|
||||
(let ((body (rb-p-parse-stmts (list "end"))))
|
||||
(rb-p-expect-kw! "end")
|
||||
{:type "module-def" :name name :body body}))))
|
||||
|
||||
;; Const or Const::Const::...
|
||||
(define rb-p-parse-const-path
|
||||
(fn ()
|
||||
(let ((node {:type "const" :name (rb-p-val)}))
|
||||
(rb-p-advance!)
|
||||
(define rb-p-cp-loop
|
||||
(fn ()
|
||||
(when (= (rb-p-type) "dcolon")
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(let ((name (rb-p-val)))
|
||||
(rb-p-advance!)
|
||||
(set! node {:type "const-path" :left node :name name})
|
||||
(rb-p-cp-loop))))))
|
||||
(rb-p-cp-loop)
|
||||
node)))
|
||||
|
||||
;; [e, *e, ...]
|
||||
(define rb-p-parse-array
|
||||
(fn ()
|
||||
(rb-p-advance!)
|
||||
(rb-p-skip-newlines!)
|
||||
(let ((elems (list)))
|
||||
(define rb-p-arr-loop
|
||||
(fn ()
|
||||
(when (not (or (= (rb-p-type) "rbracket") (= (rb-p-type) "eof")))
|
||||
(do
|
||||
(if (and (= (rb-p-type) "op") (= (rb-p-val) "*"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(append! elems {:type "splat" :value (rb-p-parse-assign)}))
|
||||
(append! elems (rb-p-parse-assign)))
|
||||
(rb-p-skip-newlines!)
|
||||
(when (= (rb-p-type) "comma")
|
||||
(do (rb-p-advance!) (rb-p-skip-newlines!)))
|
||||
(rb-p-arr-loop)))))
|
||||
(rb-p-arr-loop)
|
||||
(rb-p-expect! "rbracket")
|
||||
{:type "array" :elems elems})))
|
||||
|
||||
;; {k: v, k => v, ...}
|
||||
(define rb-p-parse-hash
|
||||
(fn ()
|
||||
(rb-p-advance!)
|
||||
(rb-p-skip-newlines!)
|
||||
(let ((pairs (list)))
|
||||
(define rb-p-hash-loop
|
||||
(fn ()
|
||||
(when (not (or (= (rb-p-type) "rbrace") (= (rb-p-type) "eof")))
|
||||
(do
|
||||
(let ((key nil) (val nil) (style nil))
|
||||
(cond
|
||||
((and (or (= (rb-p-type) "ident") (= (rb-p-type) "const"))
|
||||
(= (get (rb-p-peek 1) :type) "colon"))
|
||||
(do
|
||||
(set! key {:type "lit-sym" :value (rb-p-val)})
|
||||
(set! style "colon")
|
||||
(rb-p-advance!)
|
||||
(rb-p-advance!)))
|
||||
(:else
|
||||
(do
|
||||
(set! key (rb-p-parse-assign))
|
||||
(set! style "rocket")
|
||||
(when (and (= (rb-p-type) "op") (= (rb-p-val) "=>"))
|
||||
(rb-p-advance!)))))
|
||||
(rb-p-skip-newlines!)
|
||||
(set! val (rb-p-parse-assign))
|
||||
(append! pairs {:key key :val val :style style}))
|
||||
(rb-p-skip-newlines!)
|
||||
(when (= (rb-p-type) "comma")
|
||||
(do (rb-p-advance!) (rb-p-skip-newlines!)))
|
||||
(rb-p-hash-loop)))))
|
||||
(rb-p-hash-loop)
|
||||
(rb-p-expect! "rbrace")
|
||||
{:type "hash" :pairs pairs})))
|
||||
|
||||
;; (a, *b, **c, &d)
|
||||
(define rb-p-parse-args-parens
|
||||
(fn ()
|
||||
(rb-p-advance!)
|
||||
(rb-p-skip-newlines!)
|
||||
(let ((args (list)))
|
||||
(define rb-p-ap-loop
|
||||
(fn ()
|
||||
(when (not (or (= (rb-p-type) "rparen") (= (rb-p-type) "eof")))
|
||||
(do
|
||||
(cond
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "**"))
|
||||
(do (rb-p-advance!)
|
||||
(append! args {:type "dsplat" :value (rb-p-parse-assign)})))
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "*"))
|
||||
(do (rb-p-advance!)
|
||||
(append! args {:type "splat" :value (rb-p-parse-assign)})))
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "&"))
|
||||
(do (rb-p-advance!)
|
||||
(append! args {:type "block-pass" :value (rb-p-parse-assign)})))
|
||||
(:else (append! args (rb-p-parse-assign))))
|
||||
(rb-p-skip-newlines!)
|
||||
(when (= (rb-p-type) "comma")
|
||||
(do (rb-p-advance!) (rb-p-skip-newlines!)))
|
||||
(rb-p-ap-loop)))))
|
||||
(rb-p-ap-loop)
|
||||
(rb-p-expect! "rparen")
|
||||
args)))
|
||||
|
||||
;; No-paren arg list up to sep/end-keyword
|
||||
(define rb-p-parse-args-bare
|
||||
(fn ()
|
||||
(let ((args (list)) (going true))
|
||||
(define rb-p-ab-loop
|
||||
(fn ()
|
||||
(when (and going
|
||||
(not (rb-p-sep?))
|
||||
(not (= (rb-p-type) "eof"))
|
||||
(not (= (rb-p-type) "rparen"))
|
||||
(not (= (rb-p-type) "rbracket"))
|
||||
(not (= (rb-p-type) "rbrace"))
|
||||
(not (and (= (rb-p-type) "keyword")
|
||||
(contains? (list "end" "else" "elsif" "when"
|
||||
"rescue" "ensure" "then" "do")
|
||||
(rb-p-val)))))
|
||||
(do
|
||||
(cond
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "*"))
|
||||
(do (rb-p-advance!)
|
||||
(append! args {:type "splat" :value (rb-p-parse-assign)})))
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "**"))
|
||||
(do (rb-p-advance!)
|
||||
(append! args {:type "dsplat" :value (rb-p-parse-assign)})))
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "&"))
|
||||
(do (rb-p-advance!)
|
||||
(append! args {:type "block-pass" :value (rb-p-parse-assign)})))
|
||||
(:else (append! args (rb-p-parse-assign))))
|
||||
(if (= (rb-p-type) "comma")
|
||||
(do (rb-p-advance!) (rb-p-skip-newlines!) (rb-p-ab-loop))
|
||||
(set! going false))))))
|
||||
(rb-p-ab-loop)
|
||||
args)))
|
||||
|
||||
;; Primary expression
|
||||
(define rb-p-parse-primary
|
||||
(fn ()
|
||||
(cond
|
||||
((= (rb-p-type) "int")
|
||||
(let ((v (rb-p-val))) (rb-p-advance!) {:type "lit-int" :value v}))
|
||||
((= (rb-p-type) "float")
|
||||
(let ((v (rb-p-val))) (rb-p-advance!) {:type "lit-float" :value v}))
|
||||
((= (rb-p-type) "string")
|
||||
(let ((v (rb-p-val))) (rb-p-advance!) {:type "lit-str" :value v}))
|
||||
((= (rb-p-type) "symbol")
|
||||
(let ((v (rb-p-val))) (rb-p-advance!) {:type "lit-sym" :value v}))
|
||||
((= (rb-p-type) "words")
|
||||
(let ((v (rb-p-val))) (rb-p-advance!) {:type "lit-words" :elems v}))
|
||||
((= (rb-p-type) "isymbols")
|
||||
(let ((v (rb-p-val))) (rb-p-advance!) {:type "lit-isyms" :elems v}))
|
||||
((= (rb-p-type) "ivar")
|
||||
(let ((v (rb-p-val))) (rb-p-advance!) {:type "ivar" :name v}))
|
||||
((= (rb-p-type) "cvar")
|
||||
(let ((v (rb-p-val))) (rb-p-advance!) {:type "cvar" :name v}))
|
||||
((= (rb-p-type) "gvar")
|
||||
(let ((v (rb-p-val))) (rb-p-advance!) {:type "gvar" :name v}))
|
||||
((= (rb-p-type) "const")
|
||||
(rb-p-parse-const-path))
|
||||
((= (rb-p-type) "ident")
|
||||
(let ((name (rb-p-val)))
|
||||
(rb-p-advance!)
|
||||
(if (= (rb-p-type) "lparen")
|
||||
(let ((args (rb-p-parse-args-parens))
|
||||
(blk (rb-p-parse-block)))
|
||||
{:type "send" :name name :args args :block blk})
|
||||
{:type "send" :name name :args (list) :block nil})))
|
||||
((= (rb-p-type) "keyword")
|
||||
(cond
|
||||
((= (rb-p-val) "nil")
|
||||
(do (rb-p-advance!) {:type "lit-nil"}))
|
||||
((= (rb-p-val) "true")
|
||||
(do (rb-p-advance!) {:type "lit-bool" :value true}))
|
||||
((= (rb-p-val) "false")
|
||||
(do (rb-p-advance!) {:type "lit-bool" :value false}))
|
||||
((= (rb-p-val) "self")
|
||||
(do (rb-p-advance!) {:type "self"}))
|
||||
((= (rb-p-val) "super")
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(let ((args (if (= (rb-p-type) "lparen")
|
||||
(rb-p-parse-args-parens) (list)))
|
||||
(blk (rb-p-parse-block)))
|
||||
{:type "send" :name "super" :args args :block blk})))
|
||||
(:else
|
||||
{:type "error"
|
||||
:msg (join "" (list "unexpected kw " (rb-p-val)))})))
|
||||
((= (rb-p-type) "lbracket")
|
||||
(rb-p-parse-array))
|
||||
((= (rb-p-type) "lbrace")
|
||||
(rb-p-parse-hash))
|
||||
((= (rb-p-type) "lparen")
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(rb-p-skip-seps!)
|
||||
(let ((node (rb-p-parse-expr)))
|
||||
(rb-p-skip-seps!)
|
||||
(rb-p-expect! "rparen")
|
||||
node)))
|
||||
(:else
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
{:type "error"
|
||||
:msg (join "" (list "unexpected " (rb-p-type)
|
||||
" '" (or (rb-p-val) "") "'"))})))))
|
||||
|
||||
;; .method ::Const [index] chains
|
||||
(define rb-p-parse-postfix
|
||||
(fn ()
|
||||
(let ((node (rb-p-parse-primary)))
|
||||
(define rb-p-pf-loop
|
||||
(fn ()
|
||||
(cond
|
||||
((= (rb-p-type) "dot")
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(let ((method (rb-p-val)))
|
||||
(rb-p-advance!)
|
||||
(let ((args (if (= (rb-p-type) "lparen")
|
||||
(rb-p-parse-args-parens) (list)))
|
||||
(blk (rb-p-parse-block)))
|
||||
(set! node {:type "call" :recv node :method method
|
||||
:args args :block blk})
|
||||
(rb-p-pf-loop)))))
|
||||
((= (rb-p-type) "dcolon")
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(let ((name (rb-p-val)))
|
||||
(rb-p-advance!)
|
||||
(if (= (rb-p-type) "lparen")
|
||||
(let ((args (rb-p-parse-args-parens))
|
||||
(blk (rb-p-parse-block)))
|
||||
(set! node {:type "call" :recv node :method name
|
||||
:args args :block blk}))
|
||||
(set! node {:type "const-path" :left node :name name}))
|
||||
(rb-p-pf-loop))))
|
||||
((= (rb-p-type) "lbracket")
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(rb-p-skip-newlines!)
|
||||
(let ((idxargs (list)))
|
||||
(define rb-p-idx-loop
|
||||
(fn ()
|
||||
(when (not (or (= (rb-p-type) "rbracket") (= (rb-p-type) "eof")))
|
||||
(do
|
||||
(append! idxargs (rb-p-parse-assign))
|
||||
(when (= (rb-p-type) "comma")
|
||||
(do (rb-p-advance!) (rb-p-skip-newlines!)))
|
||||
(rb-p-idx-loop)))))
|
||||
(rb-p-idx-loop)
|
||||
(rb-p-expect! "rbracket")
|
||||
(set! node {:type "index" :recv node :args idxargs})
|
||||
(rb-p-pf-loop))))
|
||||
(:else nil))))
|
||||
(rb-p-pf-loop)
|
||||
node)))
|
||||
|
||||
(define rb-p-parse-unary
|
||||
(fn ()
|
||||
(cond
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "!"))
|
||||
(do (rb-p-advance!)
|
||||
{:type "unop" :op "!" :value (rb-p-parse-unary)}))
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "~"))
|
||||
(do (rb-p-advance!)
|
||||
{:type "unop" :op "~" :value (rb-p-parse-unary)}))
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "-"))
|
||||
(do (rb-p-advance!)
|
||||
{:type "unop" :op "-" :value (rb-p-parse-unary)}))
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "+"))
|
||||
(do (rb-p-advance!) (rb-p-parse-unary)))
|
||||
(:else (rb-p-parse-postfix)))))
|
||||
|
||||
(define rb-p-parse-power
|
||||
(fn ()
|
||||
(let ((node (rb-p-parse-unary)))
|
||||
(if (and (= (rb-p-type) "op") (= (rb-p-val) "**"))
|
||||
(do (rb-p-advance!)
|
||||
{:type "binop" :op "**" :left node :right (rb-p-parse-power)})
|
||||
node))))
|
||||
|
||||
(define rb-p-parse-mul
|
||||
(fn ()
|
||||
(let ((node (rb-p-parse-power)))
|
||||
(define rb-p-mul-loop
|
||||
(fn ()
|
||||
(if (and (= (rb-p-type) "op")
|
||||
(or (= (rb-p-val) "*") (= (rb-p-val) "/") (= (rb-p-val) "%")))
|
||||
(let ((op (rb-p-val)))
|
||||
(rb-p-advance!)
|
||||
(set! node {:type "binop" :op op :left node :right (rb-p-parse-power)})
|
||||
(rb-p-mul-loop))
|
||||
node)))
|
||||
(rb-p-mul-loop))))
|
||||
|
||||
(define rb-p-parse-add
|
||||
(fn ()
|
||||
(let ((node (rb-p-parse-mul)))
|
||||
(define rb-p-add-loop
|
||||
(fn ()
|
||||
(if (and (= (rb-p-type) "op")
|
||||
(or (= (rb-p-val) "+") (= (rb-p-val) "-")))
|
||||
(let ((op (rb-p-val)))
|
||||
(rb-p-advance!)
|
||||
(set! node {:type "binop" :op op :left node :right (rb-p-parse-mul)})
|
||||
(rb-p-add-loop))
|
||||
node)))
|
||||
(rb-p-add-loop))))
|
||||
|
||||
(define rb-p-parse-shift
|
||||
(fn ()
|
||||
(let ((node (rb-p-parse-add)))
|
||||
(define rb-p-sh-loop
|
||||
(fn ()
|
||||
(if (and (= (rb-p-type) "op")
|
||||
(or (= (rb-p-val) "<<") (= (rb-p-val) ">>")))
|
||||
(let ((op (rb-p-val)))
|
||||
(rb-p-advance!)
|
||||
(set! node {:type "binop" :op op :left node :right (rb-p-parse-add)})
|
||||
(rb-p-sh-loop))
|
||||
node)))
|
||||
(rb-p-sh-loop))))
|
||||
|
||||
(define rb-p-parse-bitand
|
||||
(fn ()
|
||||
(let ((node (rb-p-parse-shift)))
|
||||
(define rb-p-ba-loop
|
||||
(fn ()
|
||||
(if (and (= (rb-p-type) "op") (= (rb-p-val) "&"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(set! node {:type "binop" :op "&" :left node :right (rb-p-parse-shift)})
|
||||
(rb-p-ba-loop))
|
||||
node)))
|
||||
(rb-p-ba-loop))))
|
||||
|
||||
;; | is "pipe" token (not "op")
|
||||
(define rb-p-parse-bitor
|
||||
(fn ()
|
||||
(let ((node (rb-p-parse-bitand)))
|
||||
(define rb-p-bo-loop
|
||||
(fn ()
|
||||
(cond
|
||||
((= (rb-p-type) "pipe")
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(set! node {:type "binop" :op "|" :left node :right (rb-p-parse-bitand)})
|
||||
(rb-p-bo-loop)))
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "^"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(set! node {:type "binop" :op "^" :left node :right (rb-p-parse-bitand)})
|
||||
(rb-p-bo-loop)))
|
||||
(:else node))))
|
||||
(rb-p-bo-loop))))
|
||||
|
||||
(define rb-p-parse-comparison
|
||||
(fn ()
|
||||
(let ((node (rb-p-parse-bitor)))
|
||||
(if (and (= (rb-p-type) "op")
|
||||
(contains? (list "==" "!=" "<" ">" "<=" ">="
|
||||
"<=>" "===" "=~" "!~") (rb-p-val)))
|
||||
(let ((op (rb-p-val)))
|
||||
(rb-p-advance!)
|
||||
{:type "binop" :op op :left node :right (rb-p-parse-bitor)})
|
||||
node))))
|
||||
|
||||
(define rb-p-parse-not
|
||||
(fn ()
|
||||
(if (and (= (rb-p-type) "keyword") (= (rb-p-val) "not"))
|
||||
(do (rb-p-advance!)
|
||||
{:type "not" :value (rb-p-parse-not)})
|
||||
(rb-p-parse-comparison))))
|
||||
|
||||
(define rb-p-parse-and
|
||||
(fn ()
|
||||
(let ((node (rb-p-parse-not)))
|
||||
(define rb-p-and-loop
|
||||
(fn ()
|
||||
(cond
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "&&"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(set! node {:type "binop" :op "&&" :left node :right (rb-p-parse-not)})
|
||||
(rb-p-and-loop)))
|
||||
((and (= (rb-p-type) "keyword") (= (rb-p-val) "and"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(set! node {:type "binop" :op "and" :left node :right (rb-p-parse-not)})
|
||||
(rb-p-and-loop)))
|
||||
(:else node))))
|
||||
(rb-p-and-loop))))
|
||||
|
||||
(define rb-p-parse-or
|
||||
(fn ()
|
||||
(let ((node (rb-p-parse-and)))
|
||||
(define rb-p-or-loop
|
||||
(fn ()
|
||||
(cond
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "||"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(set! node {:type "binop" :op "||" :left node :right (rb-p-parse-and)})
|
||||
(rb-p-or-loop)))
|
||||
((and (= (rb-p-type) "keyword") (= (rb-p-val) "or"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(set! node {:type "binop" :op "or" :left node :right (rb-p-parse-and)})
|
||||
(rb-p-or-loop)))
|
||||
(:else node))))
|
||||
(rb-p-or-loop))))
|
||||
|
||||
(define rb-p-parse-range
|
||||
(fn ()
|
||||
(let ((node (rb-p-parse-or)))
|
||||
(cond
|
||||
((= (rb-p-type) "dotdot")
|
||||
(do (rb-p-advance!)
|
||||
{:type "range" :from node :to (rb-p-parse-or) :exclusive false}))
|
||||
((= (rb-p-type) "dotdotdot")
|
||||
(do (rb-p-advance!)
|
||||
{:type "range" :from node :to (rb-p-parse-or) :exclusive true}))
|
||||
(:else node)))))
|
||||
|
||||
(define rb-p-parse-assign
|
||||
(fn ()
|
||||
(let ((node (rb-p-parse-range)))
|
||||
(cond
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "="))
|
||||
(do (rb-p-advance!)
|
||||
{:type "assign" :target node :value (rb-p-parse-assign)}))
|
||||
((and (= (rb-p-type) "op")
|
||||
(contains? (list "+=" "-=" "*=" "/=" "%=" "**="
|
||||
"<<=" ">>=" "&=" "|=" "^=" "&&=" "||=")
|
||||
(rb-p-val)))
|
||||
(let ((op (substring (rb-p-val) 0 (- (len (rb-p-val)) 1))))
|
||||
(rb-p-advance!)
|
||||
{:type "op-assign" :target node :op op :value (rb-p-parse-assign)}))
|
||||
(:else node)))))
|
||||
|
||||
(define rb-p-parse-expr
|
||||
(fn () (rb-p-parse-assign)))
|
||||
|
||||
;; e, e, ... → single node or array
|
||||
(define rb-p-parse-multi-val
|
||||
(fn ()
|
||||
(let ((vals (list)))
|
||||
(define rb-p-mv-loop
|
||||
(fn ()
|
||||
(append! vals (rb-p-parse-assign))
|
||||
(when (= (rb-p-type) "comma")
|
||||
(do (rb-p-advance!) (rb-p-skip-newlines!) (rb-p-mv-loop)))))
|
||||
(rb-p-mv-loop)
|
||||
(if (= (len vals) 1)
|
||||
(nth vals 0)
|
||||
{:type "array" :elems vals}))))
|
||||
|
||||
;; a, b, *c = rhs
|
||||
(define rb-p-parse-massign
|
||||
(fn ()
|
||||
(let ((targets (list)))
|
||||
(define rb-p-ma-loop
|
||||
(fn ()
|
||||
(cond
|
||||
((and (= (rb-p-type) "op") (= (rb-p-val) "*"))
|
||||
(do
|
||||
(rb-p-advance!)
|
||||
(if (= (rb-p-type) "ident")
|
||||
(do
|
||||
(append! targets {:type "splat-target" :name (rb-p-val)})
|
||||
(rb-p-advance!))
|
||||
(append! targets {:type "splat-target" :name nil}))))
|
||||
((= (rb-p-type) "ident")
|
||||
(do (append! targets {:type "lvar" :name (rb-p-val)}) (rb-p-advance!)))
|
||||
((= (rb-p-type) "ivar")
|
||||
(do (append! targets {:type "ivar" :name (rb-p-val)}) (rb-p-advance!)))
|
||||
((= (rb-p-type) "cvar")
|
||||
(do (append! targets {:type "cvar" :name (rb-p-val)}) (rb-p-advance!)))
|
||||
((= (rb-p-type) "gvar")
|
||||
(do (append! targets {:type "gvar" :name (rb-p-val)}) (rb-p-advance!)))
|
||||
((= (rb-p-type) "const")
|
||||
(do (append! targets {:type "const" :name (rb-p-val)}) (rb-p-advance!)))
|
||||
(:else nil))
|
||||
(when (= (rb-p-type) "comma")
|
||||
(do (rb-p-advance!) (rb-p-skip-newlines!) (rb-p-ma-loop)))))
|
||||
(rb-p-ma-loop)
|
||||
(rb-p-advance!)
|
||||
{:type "massign" :targets targets :value (rb-p-parse-multi-val)})))
|
||||
|
||||
(define rb-p-parse-stmt
|
||||
(fn ()
|
||||
(cond
|
||||
((and (= (rb-p-type) "keyword") (= (rb-p-val) "def"))
|
||||
(rb-p-parse-def))
|
||||
((and (= (rb-p-type) "keyword") (= (rb-p-val) "class"))
|
||||
(rb-p-parse-class))
|
||||
((and (= (rb-p-type) "keyword") (= (rb-p-val) "module"))
|
||||
(rb-p-parse-module))
|
||||
((and (= (rb-p-type) "keyword") (= (rb-p-val) "return"))
|
||||
(do (rb-p-advance!)
|
||||
{:type "return"
|
||||
:value (if (or (rb-p-sep?) (= (rb-p-type) "eof"))
|
||||
nil (rb-p-parse-multi-val))}))
|
||||
((and (= (rb-p-type) "keyword") (= (rb-p-val) "yield"))
|
||||
(do (rb-p-advance!)
|
||||
{:type "yield"
|
||||
:args (cond
|
||||
((= (rb-p-type) "lparen") (rb-p-parse-args-parens))
|
||||
((or (rb-p-sep?) (= (rb-p-type) "eof")) (list))
|
||||
(:else (rb-p-parse-args-bare)))}))
|
||||
((and (= (rb-p-type) "keyword") (= (rb-p-val) "break"))
|
||||
(do (rb-p-advance!)
|
||||
{:type "break"
|
||||
:value (if (or (rb-p-sep?) (= (rb-p-type) "eof"))
|
||||
nil (rb-p-parse-expr))}))
|
||||
((and (= (rb-p-type) "keyword") (= (rb-p-val) "next"))
|
||||
(do (rb-p-advance!)
|
||||
{:type "next"
|
||||
:value (if (or (rb-p-sep?) (= (rb-p-type) "eof"))
|
||||
nil (rb-p-parse-expr))}))
|
||||
((and (= (rb-p-type) "keyword") (= (rb-p-val) "redo"))
|
||||
(do (rb-p-advance!) {:type "redo"}))
|
||||
((and (= (rb-p-type) "keyword") (= (rb-p-val) "raise"))
|
||||
(do (rb-p-advance!)
|
||||
{:type "raise"
|
||||
:value (if (or (rb-p-sep?) (= (rb-p-type) "eof"))
|
||||
nil (rb-p-parse-expr))}))
|
||||
;; Massign: token followed by comma
|
||||
((and (or (= (rb-p-type) "ident") (= (rb-p-type) "ivar")
|
||||
(= (rb-p-type) "cvar") (= (rb-p-type) "gvar")
|
||||
(= (rb-p-type) "const"))
|
||||
(= (get (rb-p-peek 1) :type) "comma"))
|
||||
(rb-p-parse-massign))
|
||||
(:else
|
||||
(let ((node (rb-p-parse-assign)))
|
||||
(if (and (= (get node :type) "send")
|
||||
(= (len (get node :args)) 0)
|
||||
(nil? (get node :block)))
|
||||
;; Bare send: check for block or no-paren args
|
||||
(cond
|
||||
;; Block immediately follows (do or {)
|
||||
((or (and (= (rb-p-type) "keyword") (= (rb-p-val) "do"))
|
||||
(= (rb-p-type) "lbrace"))
|
||||
(let ((blk (rb-p-parse-block)))
|
||||
{:type "send" :name (get node :name) :args (list) :block blk}))
|
||||
;; No-paren args (stop before block/sep/end keywords)
|
||||
((and (not (rb-p-sep?))
|
||||
(not (= (rb-p-type) "eof"))
|
||||
(not (= (rb-p-type) "op"))
|
||||
(not (= (rb-p-type) "dot"))
|
||||
(not (= (rb-p-type) "dcolon"))
|
||||
(not (= (rb-p-type) "rparen"))
|
||||
(not (= (rb-p-type) "rbracket"))
|
||||
(not (= (rb-p-type) "rbrace"))
|
||||
(not (= (rb-p-type) "lbrace"))
|
||||
(not (and (= (rb-p-type) "keyword")
|
||||
(contains? (list "end" "else" "elsif" "when"
|
||||
"rescue" "ensure" "then" "do"
|
||||
"and" "or" "not")
|
||||
(rb-p-val)))))
|
||||
(let ((args (rb-p-parse-args-bare))
|
||||
(blk (rb-p-parse-block)))
|
||||
(if (> (len args) 0)
|
||||
{:type "send" :name (get node :name) :args args :block blk}
|
||||
node)))
|
||||
(:else node))
|
||||
node))))))
|
||||
|
||||
(define rb-p-parse-stmts
|
||||
(fn (terminators)
|
||||
(let ((stmts (list)))
|
||||
(define rb-p-at-term?
|
||||
(fn ()
|
||||
(or (= (rb-p-type) "eof")
|
||||
(and (= (rb-p-type) "keyword")
|
||||
(contains? terminators (rb-p-val)))
|
||||
(and (= (rb-p-type) "rbrace")
|
||||
(contains? terminators "rbrace")))))
|
||||
(define rb-p-ps-loop
|
||||
(fn ()
|
||||
(rb-p-skip-seps!)
|
||||
(when (not (rb-p-at-term?))
|
||||
(do
|
||||
(append! stmts (rb-p-parse-stmt))
|
||||
(rb-p-skip-seps!)
|
||||
(rb-p-ps-loop)))))
|
||||
(rb-p-ps-loop)
|
||||
stmts)))
|
||||
|
||||
{:type "program" :stmts (rb-p-parse-stmts (list))})))
|
||||
|
||||
(define rb-parse-str
|
||||
(fn (src) (rb-parse (rb-tokenize src))))
|
||||
92
lib/ruby/test.sh
Executable file
92
lib/ruby/test.sh
Executable file
@@ -0,0 +1,92 @@
|
||||
#!/usr/bin/env bash
|
||||
# Ruby-on-SX test runner.
|
||||
# Usage:
|
||||
# bash lib/ruby/test.sh # run all tests
|
||||
# bash lib/ruby/test.sh -v # verbose
|
||||
# bash lib/ruby/test.sh tests/parse.sx # single file
|
||||
|
||||
set -euo pipefail
|
||||
cd "$(git rev-parse --show-toplevel)"
|
||||
|
||||
SX_SERVER="hosts/ocaml/_build/default/bin/sx_server.exe"
|
||||
if [ ! -x "$SX_SERVER" ]; then
|
||||
MAIN_ROOT=$(git worktree list | head -1 | awk '{print $1}')
|
||||
if [ -x "$MAIN_ROOT/$SX_SERVER" ]; then
|
||||
SX_SERVER="$MAIN_ROOT/$SX_SERVER"
|
||||
else
|
||||
echo "ERROR: sx_server.exe not found."
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
VERBOSE=""
|
||||
FILES=()
|
||||
for arg in "$@"; do
|
||||
case "$arg" in
|
||||
-v|--verbose) VERBOSE=1 ;;
|
||||
*) FILES+=("$arg") ;;
|
||||
esac
|
||||
done
|
||||
|
||||
if [ ${#FILES[@]} -eq 0 ]; then
|
||||
mapfile -t FILES < <(find lib/ruby/tests -maxdepth 2 -name '*.sx' | sort)
|
||||
fi
|
||||
|
||||
TOTAL_PASS=0
|
||||
TOTAL_FAIL=0
|
||||
FAILED_FILES=()
|
||||
|
||||
for FILE in "${FILES[@]}"; do
|
||||
[ -f "$FILE" ] || { echo "skip $FILE (not found)"; continue; }
|
||||
TMPFILE=$(mktemp)
|
||||
# Build epoch sequence: load runtime files, then test file, then eval summary.
|
||||
{
|
||||
echo "(epoch 1)"
|
||||
echo "(load \"lib/ruby/tokenizer.sx\")"
|
||||
if [ -f "lib/ruby/parser.sx" ]; then
|
||||
echo "(epoch 2)"
|
||||
echo "(load \"lib/ruby/parser.sx\")"
|
||||
fi
|
||||
echo "(epoch 3)"
|
||||
echo "(load \"$FILE\")"
|
||||
echo "(epoch 4)"
|
||||
echo "(eval \"(list rb-test-pass rb-test-fail)\")"
|
||||
} > "$TMPFILE"
|
||||
|
||||
OUTPUT=$(timeout 60 "$SX_SERVER" < "$TMPFILE" 2>&1 || true)
|
||||
rm -f "$TMPFILE"
|
||||
|
||||
# Extract epoch 4 result: (ok-len 4 N)\n<val> or (ok 4 <val>)
|
||||
LINE=$(printf '%s\n' "$OUTPUT" | awk '/^\(ok-len 4 / {getline; print; exit}')
|
||||
if [ -z "$LINE" ]; then
|
||||
LINE=$(printf '%s\n' "$OUTPUT" \
|
||||
| grep -E '^\(ok 4 \([0-9]+ [0-9]+\)\)' | tail -1 \
|
||||
| sed -E 's/^\(ok 4 //; s/\)$//')
|
||||
fi
|
||||
if [ -z "$LINE" ]; then
|
||||
echo "✗ $FILE: could not extract summary"
|
||||
printf '%s\n' "$OUTPUT" | grep -v '^(ok ' | tail -10
|
||||
TOTAL_FAIL=$((TOTAL_FAIL + 1))
|
||||
FAILED_FILES+=("$FILE")
|
||||
continue
|
||||
fi
|
||||
P=$(printf '%s\n' "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
|
||||
F=$(printf '%s\n' "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
|
||||
TOTAL_PASS=$((TOTAL_PASS + P))
|
||||
TOTAL_FAIL=$((TOTAL_FAIL + F))
|
||||
if [ "$F" -gt 0 ]; then
|
||||
FAILED_FILES+=("$FILE")
|
||||
printf '✗ %-40s %d/%d\n' "$FILE" "$P" "$((P+F))"
|
||||
elif [ "$VERBOSE" = "1" ]; then
|
||||
printf '✓ %-40s %d passed\n' "$FILE" "$P"
|
||||
fi
|
||||
done
|
||||
|
||||
TOTAL=$((TOTAL_PASS + TOTAL_FAIL))
|
||||
if [ $TOTAL_FAIL -eq 0 ]; then
|
||||
echo "✓ $TOTAL_PASS/$TOTAL ruby-on-sx tests passed"
|
||||
else
|
||||
echo "✗ $TOTAL_PASS/$TOTAL passed, $TOTAL_FAIL failed in: ${FAILED_FILES[*]}"
|
||||
fi
|
||||
|
||||
[ $TOTAL_FAIL -eq 0 ]
|
||||
439
lib/ruby/tests/parse.sx
Normal file
439
lib/ruby/tests/parse.sx
Normal file
@@ -0,0 +1,439 @@
|
||||
;; Parser tests for Ruby 2.7 subset.
|
||||
|
||||
(define rb-deep=?
|
||||
(fn (a b)
|
||||
(cond
|
||||
((= a b) true)
|
||||
((and (dict? a) (dict? b))
|
||||
(let ((ak (keys a)) (bk (keys b)))
|
||||
(if (not (= (len ak) (len bk)))
|
||||
false
|
||||
(every?
|
||||
(fn (k)
|
||||
(and (has-key? b k) (rb-deep=? (get a k) (get b k))))
|
||||
ak))))
|
||||
((and (list? a) (list? b))
|
||||
(if (not (= (len a) (len b)))
|
||||
false
|
||||
(let ((i 0) (ok true))
|
||||
(define rb-de-loop
|
||||
(fn ()
|
||||
(when (and ok (< i (len a)))
|
||||
(do
|
||||
(when (not (rb-deep=? (nth a i) (nth b i)))
|
||||
(set! ok false))
|
||||
(set! i (+ i 1))
|
||||
(rb-de-loop)))))
|
||||
(rb-de-loop)
|
||||
ok)))
|
||||
(:else false))))
|
||||
|
||||
(define rb-test-pass 0)
|
||||
(define rb-test-fail 0)
|
||||
(define rb-test-fails (list))
|
||||
|
||||
(define rb-test
|
||||
(fn (name actual expected)
|
||||
(if (rb-deep=? actual expected)
|
||||
(set! rb-test-pass (+ rb-test-pass 1))
|
||||
(do
|
||||
(set! rb-test-fail (+ rb-test-fail 1))
|
||||
(append! rb-test-fails {:name name :actual actual :expected expected})))))
|
||||
|
||||
;; Shorthand: parse src and extract :stmts list
|
||||
(define rb-p-stmts
|
||||
(fn (src)
|
||||
(get (rb-parse-str src) :stmts)))
|
||||
|
||||
;; Shorthand: parse and get first statement
|
||||
(define rb-p-first
|
||||
(fn (src)
|
||||
(nth (rb-p-stmts src) 0)))
|
||||
|
||||
;; ── Literals ─────────────────────────────────────────────────────────────────
|
||||
|
||||
(rb-test "int literal"
|
||||
(rb-p-first "42")
|
||||
{:type "lit-int" :value 42})
|
||||
|
||||
(rb-test "negative int"
|
||||
(rb-p-first "-7")
|
||||
{:type "unop" :op "-" :value {:type "lit-int" :value 7}})
|
||||
|
||||
(rb-test "float literal"
|
||||
(rb-p-first "3.14")
|
||||
{:type "lit-float" :value "3.14"})
|
||||
|
||||
(rb-test "string literal"
|
||||
(rb-p-first "\"hello\"")
|
||||
{:type "lit-str" :value "hello"})
|
||||
|
||||
(rb-test "symbol literal"
|
||||
(rb-p-first ":foo")
|
||||
{:type "lit-sym" :value "foo"})
|
||||
|
||||
(rb-test "nil literal"
|
||||
(rb-p-first "nil")
|
||||
{:type "lit-nil"})
|
||||
|
||||
(rb-test "true literal"
|
||||
(rb-p-first "true")
|
||||
{:type "lit-bool" :value true})
|
||||
|
||||
(rb-test "false literal"
|
||||
(rb-p-first "false")
|
||||
{:type "lit-bool" :value false})
|
||||
|
||||
(rb-test "self"
|
||||
(rb-p-first "self")
|
||||
{:type "self"})
|
||||
|
||||
(rb-test "%w[] words"
|
||||
(rb-p-first "%w[a b c]")
|
||||
{:type "lit-words" :elems (list "a" "b" "c")})
|
||||
|
||||
(rb-test "%i[] isymbols"
|
||||
(rb-p-first "%i[x y]")
|
||||
{:type "lit-isyms" :elems (list "x" "y")})
|
||||
|
||||
;; ── Variables ─────────────────────────────────────────────────────────────────
|
||||
|
||||
(rb-test "local var / send"
|
||||
(rb-p-first "x")
|
||||
{:type "send" :name "x" :args (list) :block nil})
|
||||
|
||||
(rb-test "ivar"
|
||||
(rb-p-first "@foo")
|
||||
{:type "ivar" :name "@foo"})
|
||||
|
||||
(rb-test "cvar"
|
||||
(rb-p-first "@@count")
|
||||
{:type "cvar" :name "@@count"})
|
||||
|
||||
(rb-test "gvar"
|
||||
(rb-p-first "$stdout")
|
||||
{:type "gvar" :name "$stdout"})
|
||||
|
||||
(rb-test "constant"
|
||||
(rb-p-first "Foo")
|
||||
{:type "const" :name "Foo"})
|
||||
|
||||
(rb-test "const path"
|
||||
(rb-p-first "Foo::Bar")
|
||||
{:type "const-path"
|
||||
:left {:type "const" :name "Foo"}
|
||||
:name "Bar"})
|
||||
|
||||
(rb-test "triple const path"
|
||||
(rb-p-first "A::B::C")
|
||||
{:type "const-path"
|
||||
:left {:type "const-path"
|
||||
:left {:type "const" :name "A"}
|
||||
:name "B"}
|
||||
:name "C"})
|
||||
|
||||
;; ── Arrays and Hashes ─────────────────────────────────────────────────────────
|
||||
|
||||
(rb-test "empty array"
|
||||
(rb-p-first "[]")
|
||||
{:type "array" :elems (list)})
|
||||
|
||||
(rb-test "array literal"
|
||||
(rb-p-first "[1, 2, 3]")
|
||||
{:type "array" :elems (list {:type "lit-int" :value 1}
|
||||
{:type "lit-int" :value 2}
|
||||
{:type "lit-int" :value 3})})
|
||||
|
||||
(rb-test "hash colon style"
|
||||
(get (rb-p-first "{a: 1}") :type)
|
||||
"hash")
|
||||
|
||||
(rb-test "hash pair style"
|
||||
(get (nth (get (rb-p-first "{a: 1}") :pairs) 0) :style)
|
||||
"colon")
|
||||
|
||||
(rb-test "hash symbol key"
|
||||
(get (get (nth (get (rb-p-first "{a: 1}") :pairs) 0) :key) :value)
|
||||
"a")
|
||||
|
||||
;; ── Binary operators ──────────────────────────────────────────────────────────
|
||||
|
||||
(rb-test "addition"
|
||||
(rb-p-first "1 + 2")
|
||||
{:type "binop" :op "+"
|
||||
:left {:type "lit-int" :value 1}
|
||||
:right {:type "lit-int" :value 2}})
|
||||
|
||||
(rb-test "subtraction"
|
||||
(get (rb-p-first "a - b") :op)
|
||||
"-")
|
||||
|
||||
(rb-test "multiplication"
|
||||
(get (rb-p-first "x * y") :op)
|
||||
"*")
|
||||
|
||||
(rb-test "precedence: * before +"
|
||||
(rb-p-first "1 + 2 * 3")
|
||||
{:type "binop" :op "+"
|
||||
:left {:type "lit-int" :value 1}
|
||||
:right {:type "binop" :op "*"
|
||||
:left {:type "lit-int" :value 2}
|
||||
:right {:type "lit-int" :value 3}}})
|
||||
|
||||
(rb-test "power right-assoc"
|
||||
(rb-p-first "2 ** 3 ** 4")
|
||||
{:type "binop" :op "**"
|
||||
:left {:type "lit-int" :value 2}
|
||||
:right {:type "binop" :op "**"
|
||||
:left {:type "lit-int" :value 3}
|
||||
:right {:type "lit-int" :value 4}}})
|
||||
|
||||
(rb-test "equality"
|
||||
(get (rb-p-first "a == b") :op)
|
||||
"==")
|
||||
|
||||
(rb-test "logical and"
|
||||
(get (rb-p-first "a && b") :op)
|
||||
"&&")
|
||||
|
||||
(rb-test "logical or"
|
||||
(get (rb-p-first "a || b") :op)
|
||||
"||")
|
||||
|
||||
(rb-test "range inclusive"
|
||||
(rb-p-first "1..5")
|
||||
{:type "range"
|
||||
:from {:type "lit-int" :value 1}
|
||||
:to {:type "lit-int" :value 5}
|
||||
:exclusive false})
|
||||
|
||||
(rb-test "range exclusive"
|
||||
(get (rb-p-first "1...5") :exclusive)
|
||||
true)
|
||||
|
||||
;; ── Assignment ────────────────────────────────────────────────────────────────
|
||||
|
||||
(rb-test "assign"
|
||||
(rb-p-first "x = 1")
|
||||
{:type "assign"
|
||||
:target {:type "send" :name "x" :args (list) :block nil}
|
||||
:value {:type "lit-int" :value 1}})
|
||||
|
||||
(rb-test "op-assign +="
|
||||
(get (rb-p-first "x += 1") :type)
|
||||
"op-assign")
|
||||
|
||||
(rb-test "op-assign op"
|
||||
(get (rb-p-first "x += 1") :op)
|
||||
"+")
|
||||
|
||||
(rb-test "massign"
|
||||
(get (rb-p-first "a, b = 1, 2") :type)
|
||||
"massign")
|
||||
|
||||
(rb-test "massign targets"
|
||||
(len (get (rb-p-first "a, b = 1, 2") :targets))
|
||||
2)
|
||||
|
||||
(rb-test "massign value array"
|
||||
(get (get (rb-p-first "a, b = 1, 2") :value) :type)
|
||||
"array")
|
||||
|
||||
;; ── Method calls ──────────────────────────────────────────────────────────────
|
||||
|
||||
(rb-test "call with parens"
|
||||
(rb-p-first "foo(1, 2)")
|
||||
{:type "send" :name "foo"
|
||||
:args (list {:type "lit-int" :value 1}
|
||||
{:type "lit-int" :value 2})
|
||||
:block nil})
|
||||
|
||||
(rb-test "chained call"
|
||||
(get (rb-p-first "obj.foo") :type)
|
||||
"call")
|
||||
|
||||
(rb-test "chained call method"
|
||||
(get (rb-p-first "obj.foo") :method)
|
||||
"foo")
|
||||
|
||||
(rb-test "chained call with args"
|
||||
(len (get (rb-p-first "obj.foo(1, 2)") :args))
|
||||
2)
|
||||
|
||||
(rb-test "no-paren call"
|
||||
(get (rb-p-first "puts \"hello\"") :type)
|
||||
"send")
|
||||
|
||||
(rb-test "no-paren call name"
|
||||
(get (rb-p-first "puts \"hello\"") :name)
|
||||
"puts")
|
||||
|
||||
(rb-test "no-paren call args"
|
||||
(len (get (rb-p-first "puts \"hello\"") :args))
|
||||
1)
|
||||
|
||||
(rb-test "indexing"
|
||||
(get (rb-p-first "a[0]") :type)
|
||||
"index")
|
||||
|
||||
;; ── Unary operators ───────────────────────────────────────────────────────────
|
||||
|
||||
(rb-test "unary not"
|
||||
(rb-p-first "!x")
|
||||
{:type "unop" :op "!"
|
||||
:value {:type "send" :name "x" :args (list) :block nil}})
|
||||
|
||||
(rb-test "unary minus"
|
||||
(get (rb-p-first "-x") :op)
|
||||
"-")
|
||||
|
||||
;; ── Method def ────────────────────────────────────────────────────────────────
|
||||
|
||||
(rb-test "empty method def"
|
||||
(get (rb-p-first "def foo; end") :type)
|
||||
"method-def")
|
||||
|
||||
(rb-test "method def name"
|
||||
(get (rb-p-first "def foo; end") :name)
|
||||
"foo")
|
||||
|
||||
(rb-test "method def no params"
|
||||
(len (get (rb-p-first "def foo; end") :params))
|
||||
0)
|
||||
|
||||
(rb-test "method def with params"
|
||||
(len (get (rb-p-first "def foo(a, b); end") :params))
|
||||
2)
|
||||
|
||||
(rb-test "method def param-req"
|
||||
(get (nth (get (rb-p-first "def foo(a); end") :params) 0) :type)
|
||||
"param-req")
|
||||
|
||||
(rb-test "method def param name"
|
||||
(get (nth (get (rb-p-first "def foo(a); end") :params) 0) :name)
|
||||
"a")
|
||||
|
||||
(rb-test "method def optional param"
|
||||
(get (nth (get (rb-p-first "def foo(a, b=1); end") :params) 1) :type)
|
||||
"param-opt")
|
||||
|
||||
(rb-test "method def splat"
|
||||
(get (nth (get (rb-p-first "def foo(*args); end") :params) 0) :type)
|
||||
"param-rest")
|
||||
|
||||
(rb-test "method def double splat"
|
||||
(get (nth (get (rb-p-first "def foo(**opts); end") :params) 0) :type)
|
||||
"param-kwrest")
|
||||
|
||||
(rb-test "method def block param"
|
||||
(get (nth (get (rb-p-first "def foo(&blk); end") :params) 0) :type)
|
||||
"param-block")
|
||||
|
||||
(rb-test "method def all param types"
|
||||
(len (get (rb-p-first "def foo(a, b=1, *c, **d, &e); end") :params))
|
||||
5)
|
||||
|
||||
(rb-test "method def singleton recv"
|
||||
(get (get (rb-p-first "def self.bar; end") :recv) :type)
|
||||
"self")
|
||||
|
||||
(rb-test "method def body"
|
||||
(len (get (rb-p-first "def foo; 1; 2; end") :body))
|
||||
2)
|
||||
|
||||
;; ── Class def ────────────────────────────────────────────────────────────────
|
||||
|
||||
(rb-test "class def type"
|
||||
(get (rb-p-first "class Foo; end") :type)
|
||||
"class-def")
|
||||
|
||||
(rb-test "class def name"
|
||||
(get (get (rb-p-first "class Foo; end") :name) :name)
|
||||
"Foo")
|
||||
|
||||
(rb-test "class def no super"
|
||||
(nil? (get (rb-p-first "class Foo; end") :super))
|
||||
true)
|
||||
|
||||
(rb-test "class def with super"
|
||||
(get (get (rb-p-first "class Foo < Bar; end") :super) :name)
|
||||
"Bar")
|
||||
|
||||
(rb-test "singleton class"
|
||||
(get (rb-p-first "class << self; end") :type)
|
||||
"sclass")
|
||||
|
||||
;; ── Module def ────────────────────────────────────────────────────────────────
|
||||
|
||||
(rb-test "module def type"
|
||||
(get (rb-p-first "module M; end") :type)
|
||||
"module-def")
|
||||
|
||||
(rb-test "module def name"
|
||||
(get (get (rb-p-first "module M; end") :name) :name)
|
||||
"M")
|
||||
|
||||
;; ── Blocks ────────────────────────────────────────────────────────────────────
|
||||
|
||||
(rb-test "block do...end"
|
||||
(get (get (rb-p-first "foo do |x| x end") :block) :type)
|
||||
"block")
|
||||
|
||||
(rb-test "block brace"
|
||||
(get (get (rb-p-first "foo { |x| x }") :block) :type)
|
||||
"block")
|
||||
|
||||
(rb-test "block params"
|
||||
(len (get (get (rb-p-first "foo { |a, b| a }") :block) :params))
|
||||
2)
|
||||
|
||||
(rb-test "block no params"
|
||||
(len (get (get (rb-p-first "foo { 42 }") :block) :params))
|
||||
0)
|
||||
|
||||
;; ── Control flow ──────────────────────────────────────────────────────────────
|
||||
|
||||
(rb-test "return type"
|
||||
(get (rb-p-first "return 1") :type)
|
||||
"return")
|
||||
|
||||
(rb-test "return value"
|
||||
(get (get (rb-p-first "return 1") :value) :value)
|
||||
1)
|
||||
|
||||
(rb-test "return nil"
|
||||
(nil? (get (rb-p-first "return") :value))
|
||||
true)
|
||||
|
||||
(rb-test "yield type"
|
||||
(get (rb-p-first "yield 1") :type)
|
||||
"yield")
|
||||
|
||||
(rb-test "break type"
|
||||
(get (rb-p-first "break") :type)
|
||||
"break")
|
||||
|
||||
(rb-test "next type"
|
||||
(get (rb-p-first "next") :type)
|
||||
"next")
|
||||
|
||||
(rb-test "redo type"
|
||||
(get (rb-p-first "redo") :type)
|
||||
"redo")
|
||||
|
||||
;; ── Multi-statement program ───────────────────────────────────────────────────
|
||||
|
||||
(rb-test "two statements"
|
||||
(len (rb-p-stmts "1\n2"))
|
||||
2)
|
||||
|
||||
(rb-test "semi-separated"
|
||||
(len (rb-p-stmts "1; 2; 3"))
|
||||
3)
|
||||
|
||||
(rb-test "class with method"
|
||||
(let ((cls (rb-p-first "class Foo\n def bar\n 1\n end\nend")))
|
||||
(len (get cls :body)))
|
||||
1)
|
||||
|
||||
(list rb-test-pass rb-test-fail)
|
||||
210
lib/ruby/tests/tokenizer.sx
Normal file
210
lib/ruby/tests/tokenizer.sx
Normal file
@@ -0,0 +1,210 @@
|
||||
;; Ruby tokenizer tests.
|
||||
;; Final value: {:pass N :fail N :fails (list)}
|
||||
|
||||
(define rb-deep=?
|
||||
(fn (a b)
|
||||
(cond
|
||||
((= a b) true)
|
||||
((and (dict? a) (dict? b))
|
||||
(let ((ak (keys a)) (bk (keys b)))
|
||||
(if (not (= (len ak) (len bk)))
|
||||
false
|
||||
(every?
|
||||
(fn (k) (and (has-key? b k) (rb-deep=? (get a k) (get b k))))
|
||||
ak))))
|
||||
((and (list? a) (list? b))
|
||||
(if (not (= (len a) (len b)))
|
||||
false
|
||||
(let ((i 0) (ok true))
|
||||
(define rb-de-loop
|
||||
(fn ()
|
||||
(when (and ok (< i (len a)))
|
||||
(do
|
||||
(when (not (rb-deep=? (nth a i) (nth b i)))
|
||||
(set! ok false))
|
||||
(set! i (+ i 1))
|
||||
(rb-de-loop)))))
|
||||
(rb-de-loop)
|
||||
ok)))
|
||||
(:else false))))
|
||||
|
||||
(define rb-test-pass 0)
|
||||
(define rb-test-fail 0)
|
||||
(define rb-test-fails (list))
|
||||
|
||||
(define rb-test
|
||||
(fn (name actual expected)
|
||||
(if (rb-deep=? actual expected)
|
||||
(set! rb-test-pass (+ rb-test-pass 1))
|
||||
(do
|
||||
(set! rb-test-fail (+ rb-test-fail 1))
|
||||
(append! rb-test-fails {:name name :actual actual :expected expected})))))
|
||||
|
||||
;; Helper: tokenize, drop newline+eof, return {:type :value} pairs
|
||||
(define rb-toks
|
||||
(fn (src)
|
||||
(map
|
||||
(fn (tok) {:value (get tok "value") :type (get tok "type")})
|
||||
(filter
|
||||
(fn (tok)
|
||||
(let ((ty (get tok "type")))
|
||||
(not (or (= ty "newline") (= ty "eof")))))
|
||||
(rb-tokenize src)))))
|
||||
|
||||
;; Helper: get just types
|
||||
(define rb-types
|
||||
(fn (src) (map (fn (t) (get t "type")) (rb-toks src))))
|
||||
|
||||
;; Helper: get first token type
|
||||
(define rb-first-type
|
||||
(fn (src) (get (get (rb-tokenize src) 0) "type")))
|
||||
|
||||
(define rb-first-value
|
||||
(fn (src) (get (get (rb-tokenize src) 0) "value")))
|
||||
|
||||
;; ── 1. Keywords ────────────────────────<E29480><E29480><EFBFBD>─────────────────────────
|
||||
(rb-test "keyword def" (rb-toks "def") (list {:value "def" :type "keyword"}))
|
||||
(rb-test "keyword end" (rb-toks "end") (list {:value "end" :type "keyword"}))
|
||||
(rb-test "keyword class" (rb-toks "class") (list {:value "class" :type "keyword"}))
|
||||
(rb-test "keyword if" (rb-toks "if") (list {:value "if" :type "keyword"}))
|
||||
(rb-test "keyword while" (rb-toks "while") (list {:value "while" :type "keyword"}))
|
||||
(rb-test "keyword nil" (rb-toks "nil") (list {:value "nil" :type "keyword"}))
|
||||
(rb-test "keyword true" (rb-toks "true") (list {:value "true" :type "keyword"}))
|
||||
(rb-test "keyword false" (rb-toks "false") (list {:value "false" :type "keyword"}))
|
||||
(rb-test "keyword return" (rb-toks "return") (list {:value "return" :type "keyword"}))
|
||||
(rb-test "keyword yield" (rb-toks "yield") (list {:value "yield" :type "keyword"}))
|
||||
(rb-test "keyword begin" (rb-toks "begin") (list {:value "begin" :type "keyword"}))
|
||||
(rb-test "keyword rescue" (rb-toks "rescue") (list {:value "rescue" :type "keyword"}))
|
||||
(rb-test "keyword self" (rb-toks "self") (list {:value "self" :type "keyword"}))
|
||||
(rb-test "keyword super" (rb-toks "super") (list {:value "super" :type "keyword"}))
|
||||
|
||||
;; ── 2. Identifiers ────────────────────────────────────────────────
|
||||
(rb-test "ident simple" (rb-toks "foo") (list {:value "foo" :type "ident"}))
|
||||
(rb-test "ident underscore" (rb-toks "_foo") (list {:value "_foo" :type "ident"}))
|
||||
(rb-test "ident with digit" (rb-toks "foo2") (list {:value "foo2" :type "ident"}))
|
||||
(rb-test "ident predicate" (rb-toks "empty?") (list {:value "empty?" :type "ident"}))
|
||||
(rb-test "ident bang" (rb-toks "save!") (list {:value "save!" :type "ident"}))
|
||||
(rb-test "defined?" (rb-toks "defined?") (list {:value "defined?" :type "keyword"}))
|
||||
|
||||
;; ── 3. Constants ──────────────────────────────────────────────────
|
||||
(rb-test "const simple" (rb-toks "Foo") (list {:value "Foo" :type "const"}))
|
||||
(rb-test "const upcase" (rb-toks "MY_CONST") (list {:value "MY_CONST" :type "const"}))
|
||||
(rb-test "const class" (rb-toks "String") (list {:value "String" :type "const"}))
|
||||
|
||||
;; ── 4. Sigil variables ───────────────────────────────────────────
|
||||
(rb-test "ivar" (rb-toks "@name") (list {:value "@name" :type "ivar"}))
|
||||
(rb-test "cvar" (rb-toks "@@count") (list {:value "@@count" :type "cvar"}))
|
||||
(rb-test "gvar" (rb-toks "$global") (list {:value "$global" :type "gvar"}))
|
||||
|
||||
;; ── 5. Integers ───────────────────────────────────────────────────
|
||||
(rb-test "int decimal" (rb-first-value "42") 42)
|
||||
(rb-test "int zero" (rb-first-value "0") 0)
|
||||
(rb-test "int underscore" (rb-first-value "1_000") 1000)
|
||||
(rb-test "int hex" (rb-first-value "0xFF") 255)
|
||||
(rb-test "int hex lower" (rb-first-value "0xff") 255)
|
||||
(rb-test "int octal" (rb-first-value "0o17") 15)
|
||||
(rb-test "int binary" (rb-first-value "0b1010") 10)
|
||||
(rb-test "int type" (rb-first-type "42") "int")
|
||||
|
||||
;; ── 6. Floats ─────────────────────────────────────────────────────
|
||||
(rb-test "float simple" (rb-first-type "3.14") "float")
|
||||
(rb-test "float value" (rb-first-value "3.14") "3.14")
|
||||
(rb-test "float exp" (rb-first-type "1.5e10") "float")
|
||||
(rb-test "float exp value" (rb-first-value "1.5e10") "1.5e10")
|
||||
|
||||
;; ── 7. Strings ────────────────────────────────────────────────────
|
||||
(rb-test "dq string" (rb-first-value "\"hello\"") "hello")
|
||||
(rb-test "dq string type" (rb-first-type "\"hello\"") "string")
|
||||
(rb-test "sq string" (rb-first-value "'world'") "world")
|
||||
(rb-test "dq escape nl" (rb-first-value "\"a\\nb\"") "a\nb")
|
||||
(rb-test "dq escape tab" (rb-first-value "\"a\\tb\"") "a\tb")
|
||||
(rb-test "dq escape quote" (rb-first-value "\"a\\\"b\"") "a\"b")
|
||||
(rb-test "sq no escape" (rb-first-value "'a\\nb'") "a\\nb")
|
||||
(rb-test "sq escape backslash" (rb-first-value "'a\\\\'") "a\\")
|
||||
(rb-test "dq interp kept" (rb-first-value "\"#{x}\"") "#{x}")
|
||||
|
||||
;; ── 8. Symbols ────────────────────────────────────────────────────
|
||||
(rb-test "symbol simple" (rb-first-type ":foo") "symbol")
|
||||
(rb-test "symbol value" (rb-first-value ":foo") "foo")
|
||||
(rb-test "symbol predicate" (rb-first-value ":empty?") "empty?")
|
||||
(rb-test "symbol dq" (rb-first-value ":\"hello world\"") "hello world")
|
||||
(rb-test "symbol sq" (rb-first-value ":'hello'") "hello")
|
||||
|
||||
;; ── 9. %w and %i literals ────────────────────────────────────────
|
||||
(rb-test "%w bracket" (rb-first-type "%w[a b c]") "words")
|
||||
(rb-test "%w value" (rb-first-value "%w[a b c]") (list "a" "b" "c"))
|
||||
(rb-test "%w paren" (rb-first-value "%w(x y)") (list "x" "y"))
|
||||
(rb-test "%i bracket" (rb-first-type "%i[a b]") "isymbols")
|
||||
(rb-test "%i value" (rb-first-value "%i[foo bar]") (list "foo" "bar"))
|
||||
|
||||
;; ── 10. Punctuation ───────────────────────────────────────────────
|
||||
(rb-test "dot" (rb-first-type ".") "dot")
|
||||
(rb-test "dotdot" (rb-first-type "..") "dotdot")
|
||||
(rb-test "dotdotdot" (rb-first-type "...") "dotdotdot")
|
||||
(rb-test "dcolon" (rb-first-type "::") "dcolon")
|
||||
(rb-test "comma" (rb-first-type ",") "comma")
|
||||
(rb-test "semi" (rb-first-type ";") "semi")
|
||||
(rb-test "lparen" (rb-first-type "(") "lparen")
|
||||
(rb-test "rparen" (rb-first-type ")") "rparen")
|
||||
(rb-test "lbracket" (rb-first-type "[") "lbracket")
|
||||
(rb-test "rbracket" (rb-first-type "]") "rbracket")
|
||||
(rb-test "lbrace" (rb-first-type "{") "lbrace")
|
||||
(rb-test "rbrace" (rb-first-type "}") "rbrace")
|
||||
(rb-test "pipe" (rb-first-type "|") "pipe")
|
||||
|
||||
;; ── 11. Operators ─────────────────────────────────────────────────
|
||||
(rb-test "op plus" (rb-first-value "+") "+")
|
||||
(rb-test "op minus" (rb-first-value "-") "-")
|
||||
(rb-test "op star" (rb-first-value "*") "*")
|
||||
(rb-test "op slash" (rb-first-value "/") "/")
|
||||
(rb-test "op eq" (rb-first-value "=") "=")
|
||||
(rb-test "op eqeq" (rb-first-value "==") "==")
|
||||
(rb-test "op neq" (rb-first-value "!=") "!=")
|
||||
(rb-test "op lt" (rb-first-value "<") "<")
|
||||
(rb-test "op gt" (rb-first-value ">") ">")
|
||||
(rb-test "op lte" (rb-first-value "<=") "<=")
|
||||
(rb-test "op gte" (rb-first-value ">=") ">=")
|
||||
(rb-test "op spaceship" (rb-first-value "<=>") "<=>")
|
||||
(rb-test "op tripleq" (rb-first-value "===") "===")
|
||||
(rb-test "op match" (rb-first-value "=~") "=~")
|
||||
(rb-test "op nomatch" (rb-first-value "!~") "!~")
|
||||
(rb-test "op lshift" (rb-first-value "<<") "<<")
|
||||
(rb-test "op rshift" (rb-first-value ">>") ">>")
|
||||
(rb-test "op and" (rb-first-value "&&") "&&")
|
||||
(rb-test "op or" (rb-first-value "||") "||")
|
||||
(rb-test "op power" (rb-first-value "**") "**")
|
||||
(rb-test "op plus-eq" (rb-first-value "+=") "+=")
|
||||
(rb-test "op minus-eq" (rb-first-value "-=") "-=")
|
||||
(rb-test "op arrow" (rb-first-value "->") "->")
|
||||
(rb-test "op hash-rocket" (rb-first-value "=>") "=>")
|
||||
|
||||
;; ── 12. Comments ──────────────────────────────────────────────────
|
||||
(rb-test "comment skipped" (len (rb-toks "# this is a comment")) 0)
|
||||
(rb-test "comment mid-line" (rb-types "x = 1 # comment") (list "ident" "op" "int"))
|
||||
|
||||
;; ── 13. Multi-token sequences ─────────────────────────────────────
|
||||
(rb-test "method call" (rb-types "foo.bar")
|
||||
(list "ident" "dot" "ident"))
|
||||
(rb-test "class def" (rb-types "class Foo")
|
||||
(list "keyword" "const"))
|
||||
(rb-test "method def" (rb-types "def greet(name)")
|
||||
(list "keyword" "ident" "lparen" "ident" "rparen"))
|
||||
(rb-test "assignment" (rb-types "x = 42")
|
||||
(list "ident" "op" "int"))
|
||||
(rb-test "block params" (rb-types "|x, y|")
|
||||
(list "pipe" "ident" "comma" "ident" "pipe"))
|
||||
(rb-test "scope resolution" (rb-types "Foo::Bar")
|
||||
(list "const" "dcolon" "const"))
|
||||
(rb-test "range" (rb-types "1..10")
|
||||
(list "int" "dotdot" "int"))
|
||||
(rb-test "exclusive range" (rb-types "1...10")
|
||||
(list "int" "dotdotdot" "int"))
|
||||
|
||||
;; ── 14. Line/col tracking ────────────────────────────────────────
|
||||
(define rb-tok1 (get (rb-tokenize "hello\nworld") 0))
|
||||
(define rb-tok2 (get (rb-tokenize "hello\nworld") 2))
|
||||
(rb-test "line track start" (get rb-tok1 "line") 1)
|
||||
(rb-test "line track second" (get rb-tok2 "line") 2)
|
||||
(rb-test "col track start" (get rb-tok1 "col") 1)
|
||||
|
||||
(list rb-test-pass rb-test-fail)
|
||||
549
lib/ruby/tokenizer.sx
Normal file
549
lib/ruby/tokenizer.sx
Normal file
@@ -0,0 +1,549 @@
|
||||
;; Ruby tokenizer for Ruby 2.7 subset.
|
||||
;; Token: {:type T :value V :line L :col C}
|
||||
;;
|
||||
;; Types: keyword ident ivar cvar gvar const
|
||||
;; int float string symbol
|
||||
;; op dot dotdot dotdotdot dcolon colon
|
||||
;; lparen rparen lbracket rbracket lbrace rbrace
|
||||
;; comma semi pipe newline words isymbols eof
|
||||
|
||||
;; ── Character code table ──────────────────────────────────────────
|
||||
(define rb-ord-table
|
||||
(let ((t (dict)) (i 0))
|
||||
(define rb-build-table
|
||||
(fn ()
|
||||
(when (< i 128)
|
||||
(do
|
||||
(dict-set! t (char-from-code i) i)
|
||||
(set! i (+ i 1))
|
||||
(rb-build-table)))))
|
||||
(rb-build-table)
|
||||
t))
|
||||
|
||||
(define rb-ord (fn (c) (or (get rb-ord-table c) 0)))
|
||||
|
||||
;; ── Character predicates ──────────────────────────────────────────
|
||||
(define rb-digit?
|
||||
(fn (c) (and (string? c) (>= (rb-ord c) 48) (<= (rb-ord c) 57))))
|
||||
|
||||
(define rb-hex-digit?
|
||||
(fn (c)
|
||||
(and (string? c)
|
||||
(or (and (>= (rb-ord c) 48) (<= (rb-ord c) 57))
|
||||
(and (>= (rb-ord c) 97) (<= (rb-ord c) 102))
|
||||
(and (>= (rb-ord c) 65) (<= (rb-ord c) 70))))))
|
||||
|
||||
(define rb-octal-digit?
|
||||
(fn (c) (and (string? c) (>= (rb-ord c) 48) (<= (rb-ord c) 55))))
|
||||
|
||||
(define rb-binary-digit? (fn (c) (or (= c "0") (= c "1"))))
|
||||
|
||||
(define rb-lower?
|
||||
(fn (c) (and (string? c) (>= (rb-ord c) 97) (<= (rb-ord c) 122))))
|
||||
|
||||
(define rb-upper?
|
||||
(fn (c) (and (string? c) (>= (rb-ord c) 65) (<= (rb-ord c) 90))))
|
||||
|
||||
(define rb-ident-start?
|
||||
(fn (c) (or (rb-lower? c) (rb-upper? c) (= c "_"))))
|
||||
|
||||
(define rb-ident-cont?
|
||||
(fn (c) (or (rb-lower? c) (rb-upper? c) (rb-digit? c) (= c "_"))))
|
||||
|
||||
(define rb-space? (fn (c) (or (= c " ") (= c "\t") (= c "\r"))))
|
||||
|
||||
;; ── Reserved words ────────────────────────────────────────────────
|
||||
(define rb-keywords
|
||||
(list "__ENCODING__" "__LINE__" "__FILE__"
|
||||
"BEGIN" "END"
|
||||
"alias" "and"
|
||||
"begin" "break"
|
||||
"case" "class"
|
||||
"def" "defined?" "do"
|
||||
"else" "elsif" "end" "ensure"
|
||||
"false" "for"
|
||||
"if" "in"
|
||||
"module"
|
||||
"next" "nil" "not"
|
||||
"or"
|
||||
"redo" "rescue" "retry" "return"
|
||||
"self" "super"
|
||||
"then" "true"
|
||||
"undef" "unless" "until"
|
||||
"when" "while"
|
||||
"yield"))
|
||||
|
||||
(define rb-keyword? (fn (w) (contains? rb-keywords w)))
|
||||
|
||||
;; ── Token constructor ─────────────────────────────────────────────
|
||||
(define rb-make-token
|
||||
(fn (type value line col) {:type type :value value :line line :col col}))
|
||||
|
||||
;; ── Radix number parser ───────────────────────────────────────────
|
||||
(define rb-parse-radix
|
||||
(fn (s radix)
|
||||
(let ((n (len s)) (i 0) (acc 0))
|
||||
(define rb-rad-loop
|
||||
(fn ()
|
||||
(when (< i n)
|
||||
(do
|
||||
(let ((c (substring s i (+ i 1))))
|
||||
(cond
|
||||
((and (>= (rb-ord c) 48) (<= (rb-ord c) 57))
|
||||
(set! acc (+ (* acc radix) (- (rb-ord c) 48))))
|
||||
((and (>= (rb-ord c) 97) (<= (rb-ord c) 102))
|
||||
(set! acc (+ (* acc radix) (+ 10 (- (rb-ord c) 97)))))
|
||||
((and (>= (rb-ord c) 65) (<= (rb-ord c) 70))
|
||||
(set! acc (+ (* acc radix) (+ 10 (- (rb-ord c) 65)))))))
|
||||
(set! i (+ i 1))
|
||||
(rb-rad-loop)))))
|
||||
(rb-rad-loop)
|
||||
acc)))
|
||||
|
||||
;; ── Strip underscores from numeric literals ───────────────────────
|
||||
(define rb-strip-underscores
|
||||
(fn (s)
|
||||
(let ((n (len s)) (i 0) (parts (list)))
|
||||
(define rb-su-loop
|
||||
(fn ()
|
||||
(when (< i n)
|
||||
(do
|
||||
(let ((c (substring s i (+ i 1))))
|
||||
(when (not (= c "_"))
|
||||
(append! parts c)))
|
||||
(set! i (+ i 1))
|
||||
(rb-su-loop)))))
|
||||
(rb-su-loop)
|
||||
(join "" parts))))
|
||||
|
||||
;; ── Main tokenizer ────────────────────────────────────────────────
|
||||
(define rb-tokenize
|
||||
(fn (src)
|
||||
(let ((tokens (list))
|
||||
(pos 0)
|
||||
(line 1)
|
||||
(col 1)
|
||||
(src-len (len src)))
|
||||
(define rb-peek
|
||||
(fn (offset)
|
||||
(if (< (+ pos offset) src-len)
|
||||
(substring src (+ pos offset) (+ pos offset 1))
|
||||
nil)))
|
||||
(define rb-cur (fn () (rb-peek 0)))
|
||||
(define rb-advance!
|
||||
(fn ()
|
||||
(let ((c (rb-cur)))
|
||||
(set! pos (+ pos 1))
|
||||
(if (= c "\n")
|
||||
(do (set! line (+ line 1)) (set! col 1))
|
||||
(set! col (+ col 1))))))
|
||||
(define rb-advance-n!
|
||||
(fn (n)
|
||||
(when (> n 0)
|
||||
(do (rb-advance!) (rb-advance-n! (- n 1))))))
|
||||
(define rb-push!
|
||||
(fn (type value tok-line tok-col)
|
||||
(append! tokens (rb-make-token type value tok-line tok-col))))
|
||||
(define rb-read-while
|
||||
(fn (pred)
|
||||
(let ((start pos))
|
||||
(define rb-rw-loop
|
||||
(fn ()
|
||||
(when (and (< pos src-len) (pred (rb-cur)))
|
||||
(do (rb-advance!) (rb-rw-loop)))))
|
||||
(rb-rw-loop)
|
||||
(substring src start pos))))
|
||||
(define rb-skip-line-comment!
|
||||
(fn ()
|
||||
(define rb-slc-loop
|
||||
(fn ()
|
||||
(when (and (< pos src-len) (not (= (rb-cur) "\n")))
|
||||
(do (rb-advance!) (rb-slc-loop)))))
|
||||
(rb-slc-loop)))
|
||||
(define rb-read-escape
|
||||
(fn ()
|
||||
(rb-advance!)
|
||||
(let ((c (rb-cur)))
|
||||
(cond
|
||||
((= c "n") (do (rb-advance!) "\n"))
|
||||
((= c "t") (do (rb-advance!) "\t"))
|
||||
((= c "r") (do (rb-advance!) "\r"))
|
||||
((= c "\\") (do (rb-advance!) "\\"))
|
||||
((= c "'") (do (rb-advance!) "'"))
|
||||
((= c "\"") (do (rb-advance!) "\""))
|
||||
((= c "a") (do (rb-advance!) (char-from-code 7)))
|
||||
((= c "b") (do (rb-advance!) (char-from-code 8)))
|
||||
((= c "f") (do (rb-advance!) (char-from-code 12)))
|
||||
((= c "v") (do (rb-advance!) (char-from-code 11)))
|
||||
((= c "e") (do (rb-advance!) (char-from-code 27)))
|
||||
((= c "s") (do (rb-advance!) " "))
|
||||
((= c "0") (do (rb-advance!) (char-from-code 0)))
|
||||
(:else (do (rb-advance!) (str "\\" c)))))))
|
||||
(define rb-read-sq-string
|
||||
(fn ()
|
||||
(let ((parts (list)))
|
||||
(rb-advance!)
|
||||
(define rb-sq-loop
|
||||
(fn ()
|
||||
(cond
|
||||
((>= pos src-len) nil)
|
||||
((= (rb-cur) "'") (rb-advance!))
|
||||
((and (= (rb-cur) "\\")
|
||||
(let ((n (rb-peek 1)))
|
||||
(or (= n "\\") (= n "'"))))
|
||||
(do
|
||||
(rb-advance!)
|
||||
(append! parts (rb-cur))
|
||||
(rb-advance!)
|
||||
(rb-sq-loop)))
|
||||
(:else
|
||||
(do
|
||||
(append! parts (rb-cur))
|
||||
(rb-advance!)
|
||||
(rb-sq-loop))))))
|
||||
(rb-sq-loop)
|
||||
(join "" parts))))
|
||||
(define rb-read-dq-string
|
||||
(fn ()
|
||||
(let ((parts (list)))
|
||||
(rb-advance!)
|
||||
(define rb-dq-loop
|
||||
(fn ()
|
||||
(cond
|
||||
((>= pos src-len) nil)
|
||||
((= (rb-cur) "\"") (rb-advance!))
|
||||
((= (rb-cur) "\\")
|
||||
(do
|
||||
(append! parts (rb-read-escape))
|
||||
(rb-dq-loop)))
|
||||
((and (= (rb-cur) "#") (= (rb-peek 1) "{"))
|
||||
(do
|
||||
(append! parts "#{")
|
||||
(rb-advance-n! 2)
|
||||
(let ((depth 1))
|
||||
(define rb-interp-inner
|
||||
(fn ()
|
||||
(when (and (< pos src-len) (> depth 0))
|
||||
(do
|
||||
(let ((c (rb-cur)))
|
||||
(cond
|
||||
((= c "{")
|
||||
(do
|
||||
(set! depth (+ depth 1))
|
||||
(append! parts c)
|
||||
(rb-advance!)))
|
||||
((= c "}")
|
||||
(do
|
||||
(set! depth (- depth 1))
|
||||
(when (> depth 0)
|
||||
(do (append! parts c) (rb-advance!)))))
|
||||
(:else
|
||||
(do (append! parts c) (rb-advance!)))))
|
||||
(rb-interp-inner)))))
|
||||
(rb-interp-inner))
|
||||
(when (= (rb-cur) "}")
|
||||
(do (append! parts "}") (rb-advance!)))
|
||||
(rb-dq-loop)))
|
||||
(:else
|
||||
(do
|
||||
(append! parts (rb-cur))
|
||||
(rb-advance!)
|
||||
(rb-dq-loop))))))
|
||||
(rb-dq-loop)
|
||||
(join "" parts))))
|
||||
(define rb-read-percent-words
|
||||
(fn ()
|
||||
(rb-advance-n! 2)
|
||||
(let ((open-ch (rb-cur)))
|
||||
(let ((close-ch
|
||||
(cond
|
||||
((= open-ch "[") "]")
|
||||
((= open-ch "(") ")")
|
||||
((= open-ch "{") "}")
|
||||
((= open-ch "<") ">")
|
||||
(:else open-ch))))
|
||||
(rb-advance!)
|
||||
(let ((items (list)))
|
||||
(define rb-pw-skip
|
||||
(fn ()
|
||||
(when (and (< pos src-len) (or (rb-space? (rb-cur)) (= (rb-cur) "\n")))
|
||||
(do (rb-advance!) (rb-pw-skip)))))
|
||||
(define rb-pw-word
|
||||
(fn (wparts)
|
||||
(if (or (>= pos src-len)
|
||||
(rb-space? (rb-cur))
|
||||
(= (rb-cur) "\n")
|
||||
(= (rb-cur) close-ch))
|
||||
(append! items (join "" wparts))
|
||||
(do
|
||||
(append! wparts (rb-cur))
|
||||
(rb-advance!)
|
||||
(rb-pw-word wparts)))))
|
||||
(define rb-pw-loop
|
||||
(fn ()
|
||||
(rb-pw-skip)
|
||||
(when (and (< pos src-len) (not (= (rb-cur) close-ch)))
|
||||
(do
|
||||
(rb-pw-word (list))
|
||||
(rb-pw-loop)))))
|
||||
(rb-pw-loop)
|
||||
(when (= (rb-cur) close-ch) (rb-advance!))
|
||||
items)))))
|
||||
(define rb-read-ident-word
|
||||
(fn ()
|
||||
(let ((start pos))
|
||||
(rb-read-while rb-ident-cont?)
|
||||
(when (and (= (rb-cur) "?") (not (= (rb-peek 1) "=")))
|
||||
(rb-advance!))
|
||||
(when (and (= (rb-cur) "!") (not (or (= (rb-peek 1) "=") (= (rb-peek 1) "~"))))
|
||||
(rb-advance!))
|
||||
(substring src start pos))))
|
||||
(define rb-read-number!
|
||||
(fn (tok-line tok-col)
|
||||
(let ((start pos))
|
||||
(cond
|
||||
((and (= (rb-cur) "0") (let ((p (rb-peek 1))) (or (= p "b") (= p "B"))))
|
||||
(do
|
||||
(rb-advance-n! 2)
|
||||
(let ((bin-str (rb-read-while rb-binary-digit?)))
|
||||
(rb-push! "int" (rb-parse-radix bin-str 2) tok-line tok-col))))
|
||||
((and (= (rb-cur) "0") (let ((p (rb-peek 1))) (or (= p "o") (= p "O"))))
|
||||
(do
|
||||
(rb-advance-n! 2)
|
||||
(let ((oct-str (rb-read-while rb-octal-digit?)))
|
||||
(rb-push! "int" (rb-parse-radix oct-str 8) tok-line tok-col))))
|
||||
((and (= (rb-cur) "0") (let ((p (rb-peek 1))) (or (= p "x") (= p "X"))))
|
||||
(do
|
||||
(rb-advance-n! 2)
|
||||
(let ((hex-str (rb-read-while rb-hex-digit?)))
|
||||
(rb-push! "int" (rb-parse-radix hex-str 16) tok-line tok-col))))
|
||||
(:else
|
||||
(do
|
||||
(rb-read-while (fn (c) (or (rb-digit? c) (= c "_"))))
|
||||
(let ((is-float false))
|
||||
(when (and (= (rb-cur) ".") (rb-digit? (rb-peek 1)))
|
||||
(do
|
||||
(set! is-float true)
|
||||
(rb-advance!)
|
||||
(rb-read-while (fn (c) (or (rb-digit? c) (= c "_"))))))
|
||||
(when (or (= (rb-cur) "e") (= (rb-cur) "E"))
|
||||
(do
|
||||
(set! is-float true)
|
||||
(rb-advance!)
|
||||
(when (or (= (rb-cur) "+") (= (rb-cur) "-"))
|
||||
(rb-advance!))
|
||||
(rb-read-while rb-digit?)))
|
||||
(let ((num-str (rb-strip-underscores (substring src start pos))))
|
||||
(if is-float
|
||||
(rb-push! "float" num-str tok-line tok-col)
|
||||
(rb-push! "int" (parse-int num-str) tok-line tok-col))))))))))
|
||||
(define rb-read-op!
|
||||
(fn (tok-line tok-col)
|
||||
(let ((c0 (rb-cur)) (c1 (rb-peek 1)) (c2 (rb-peek 2)))
|
||||
(cond
|
||||
((and (= c0 "<") (= c1 "=") (= c2 ">"))
|
||||
(do (rb-advance-n! 3) (rb-push! "op" "<=>" tok-line tok-col)))
|
||||
((and (= c0 "=") (= c1 "=") (= c2 "="))
|
||||
(do (rb-advance-n! 3) (rb-push! "op" "===" tok-line tok-col)))
|
||||
((and (= c0 "*") (= c1 "*") (= c2 "="))
|
||||
(do (rb-advance-n! 3) (rb-push! "op" "**=" tok-line tok-col)))
|
||||
((and (= c0 "<") (= c1 "<") (= c2 "="))
|
||||
(do (rb-advance-n! 3) (rb-push! "op" "<<=" tok-line tok-col)))
|
||||
((and (= c0 ">") (= c1 ">") (= c2 "="))
|
||||
(do (rb-advance-n! 3) (rb-push! "op" ">>=" tok-line tok-col)))
|
||||
((and (= c0 "&") (= c1 "&") (= c2 "="))
|
||||
(do (rb-advance-n! 3) (rb-push! "op" "&&=" tok-line tok-col)))
|
||||
((and (= c0 "|") (= c1 "|") (= c2 "="))
|
||||
(do (rb-advance-n! 3) (rb-push! "op" "||=" tok-line tok-col)))
|
||||
((and (= c0 "*") (= c1 "*"))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "**" tok-line tok-col)))
|
||||
((and (= c0 "=") (= c1 "="))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "==" tok-line tok-col)))
|
||||
((and (= c0 "!") (= c1 "="))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "!=" tok-line tok-col)))
|
||||
((and (= c0 "<") (= c1 "="))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "<=" tok-line tok-col)))
|
||||
((and (= c0 ">") (= c1 "="))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" ">=" tok-line tok-col)))
|
||||
((and (= c0 "=") (= c1 "~"))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "=~" tok-line tok-col)))
|
||||
((and (= c0 "!") (= c1 "~"))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "!~" tok-line tok-col)))
|
||||
((and (= c0 "<") (= c1 "<"))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "<<" tok-line tok-col)))
|
||||
((and (= c0 ">") (= c1 ">"))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" ">>" tok-line tok-col)))
|
||||
((and (= c0 "&") (= c1 "&"))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "&&" tok-line tok-col)))
|
||||
((and (= c0 "|") (= c1 "|"))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "||" tok-line tok-col)))
|
||||
((and (= c0 "+") (= c1 "="))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "+=" tok-line tok-col)))
|
||||
((and (= c0 "-") (= c1 "="))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "-=" tok-line tok-col)))
|
||||
((and (= c0 "*") (= c1 "="))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "*=" tok-line tok-col)))
|
||||
((and (= c0 "/") (= c1 "="))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "/=" tok-line tok-col)))
|
||||
((and (= c0 "%") (= c1 "="))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "%=" tok-line tok-col)))
|
||||
((and (= c0 "&") (= c1 "="))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "&=" tok-line tok-col)))
|
||||
((and (= c0 "|") (= c1 "="))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "|=" tok-line tok-col)))
|
||||
((and (= c0 "^") (= c1 "="))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "^=" tok-line tok-col)))
|
||||
((and (= c0 "-") (= c1 ">"))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "->" tok-line tok-col)))
|
||||
((and (= c0 "=") (= c1 ">"))
|
||||
(do (rb-advance-n! 2) (rb-push! "op" "=>" tok-line tok-col)))
|
||||
((and (= c0 "|") (nil? c1))
|
||||
(do (rb-advance!) (rb-push! "pipe" "|" tok-line tok-col)))
|
||||
((= c0 "|")
|
||||
(do (rb-advance!) (rb-push! "pipe" "|" tok-line tok-col)))
|
||||
(:else
|
||||
(do (rb-advance!) (rb-push! "op" c0 tok-line tok-col)))))))
|
||||
(define rb-scan!
|
||||
(fn ()
|
||||
(cond
|
||||
((>= pos src-len) nil)
|
||||
((rb-space? (rb-cur)) (do (rb-advance!) (rb-scan!)))
|
||||
((= (rb-cur) "#") (do (rb-skip-line-comment!) (rb-scan!)))
|
||||
((= (rb-cur) "\n")
|
||||
(do
|
||||
(let ((l line) (c col))
|
||||
(rb-advance!)
|
||||
(rb-push! "newline" nil l c))
|
||||
(rb-scan!)))
|
||||
((rb-digit? (rb-cur))
|
||||
(do
|
||||
(let ((l line) (c col))
|
||||
(rb-read-number! l c))
|
||||
(rb-scan!)))
|
||||
((rb-ident-start? (rb-cur))
|
||||
(do
|
||||
(let ((l line) (c col))
|
||||
(let ((w (rb-read-ident-word)))
|
||||
(if (rb-keyword? w)
|
||||
(rb-push! "keyword" w l c)
|
||||
(if (rb-upper? (substring w 0 1))
|
||||
(rb-push! "const" w l c)
|
||||
(rb-push! "ident" w l c)))))
|
||||
(rb-scan!)))
|
||||
((= (rb-cur) "@")
|
||||
(do
|
||||
(let ((l line) (c col))
|
||||
(if (= (rb-peek 1) "@")
|
||||
(do
|
||||
(rb-advance-n! 2)
|
||||
(let ((name (rb-read-while rb-ident-cont?)))
|
||||
(rb-push! "cvar" (str "@@" name) l c)))
|
||||
(do
|
||||
(rb-advance!)
|
||||
(let ((name (rb-read-while rb-ident-cont?)))
|
||||
(rb-push! "ivar" (str "@" name) l c)))))
|
||||
(rb-scan!)))
|
||||
((= (rb-cur) "$")
|
||||
(do
|
||||
(let ((l line) (c col))
|
||||
(rb-advance!)
|
||||
(let ((name (rb-read-while rb-ident-cont?)))
|
||||
(rb-push! "gvar" (str "$" name) l c)))
|
||||
(rb-scan!)))
|
||||
((= (rb-cur) "\"")
|
||||
(do
|
||||
(let ((l line) (c col))
|
||||
(rb-push! "string" (rb-read-dq-string) l c))
|
||||
(rb-scan!)))
|
||||
((= (rb-cur) "'")
|
||||
(do
|
||||
(let ((l line) (c col))
|
||||
(rb-push! "string" (rb-read-sq-string) l c))
|
||||
(rb-scan!)))
|
||||
((and (= (rb-cur) ":") (= (rb-peek 1) ":"))
|
||||
(do
|
||||
(let ((l line) (c col))
|
||||
(rb-advance-n! 2)
|
||||
(rb-push! "dcolon" "::" l c))
|
||||
(rb-scan!)))
|
||||
((= (rb-cur) ":")
|
||||
(do
|
||||
(let ((l line) (c col))
|
||||
(rb-advance!)
|
||||
(cond
|
||||
((= (rb-cur) "\"")
|
||||
(rb-push! "symbol" (rb-read-dq-string) l c))
|
||||
((= (rb-cur) "'")
|
||||
(rb-push! "symbol" (rb-read-sq-string) l c))
|
||||
((rb-ident-start? (rb-cur))
|
||||
(let ((name (rb-read-ident-word)))
|
||||
(rb-push! "symbol" name l c)))
|
||||
(:else
|
||||
(rb-push! "colon" ":" l c))))
|
||||
(rb-scan!)))
|
||||
((and (= (rb-cur) "%")
|
||||
(let ((p (rb-peek 1)))
|
||||
(or (= p "w") (= p "W") (= p "i") (= p "I"))))
|
||||
(do
|
||||
(let ((l line) (c col))
|
||||
(let ((kind (rb-peek 1)))
|
||||
(let ((items (rb-read-percent-words)))
|
||||
(if (or (= kind "i") (= kind "I"))
|
||||
(rb-push! "isymbols" items l c)
|
||||
(rb-push! "words" items l c)))))
|
||||
(rb-scan!)))
|
||||
((= (rb-cur) ".")
|
||||
(do
|
||||
(let ((l line) (c col))
|
||||
(cond
|
||||
((and (= (rb-peek 1) ".") (= (rb-peek 2) "."))
|
||||
(do (rb-advance-n! 3) (rb-push! "dotdotdot" "..." l c)))
|
||||
((= (rb-peek 1) ".")
|
||||
(do (rb-advance-n! 2) (rb-push! "dotdot" ".." l c)))
|
||||
(:else
|
||||
(do (rb-advance!) (rb-push! "dot" "." l c)))))
|
||||
(rb-scan!)))
|
||||
((= (rb-cur) ",")
|
||||
(do
|
||||
(let ((l line) (c col)) (rb-push! "comma" "," l c) (rb-advance!))
|
||||
(rb-scan!)))
|
||||
((= (rb-cur) ";")
|
||||
(do
|
||||
(let ((l line) (c col)) (rb-push! "semi" ";" l c) (rb-advance!))
|
||||
(rb-scan!)))
|
||||
((= (rb-cur) "(")
|
||||
(do
|
||||
(let ((l line) (c col)) (rb-push! "lparen" "(" l c) (rb-advance!))
|
||||
(rb-scan!)))
|
||||
((= (rb-cur) ")")
|
||||
(do
|
||||
(let ((l line) (c col)) (rb-push! "rparen" ")" l c) (rb-advance!))
|
||||
(rb-scan!)))
|
||||
((= (rb-cur) "[")
|
||||
(do
|
||||
(let ((l line) (c col)) (rb-push! "lbracket" "[" l c) (rb-advance!))
|
||||
(rb-scan!)))
|
||||
((= (rb-cur) "]")
|
||||
(do
|
||||
(let ((l line) (c col)) (rb-push! "rbracket" "]" l c) (rb-advance!))
|
||||
(rb-scan!)))
|
||||
((= (rb-cur) "{")
|
||||
(do
|
||||
(let ((l line) (c col)) (rb-push! "lbrace" "{" l c) (rb-advance!))
|
||||
(rb-scan!)))
|
||||
((= (rb-cur) "}")
|
||||
(do
|
||||
(let ((l line) (c col)) (rb-push! "rbrace" "}" l c) (rb-advance!))
|
||||
(rb-scan!)))
|
||||
((or (= (rb-cur) "+") (= (rb-cur) "-") (= (rb-cur) "*")
|
||||
(= (rb-cur) "/") (= (rb-cur) "%") (= (rb-cur) "=")
|
||||
(= (rb-cur) "!") (= (rb-cur) "<") (= (rb-cur) ">")
|
||||
(= (rb-cur) "&") (= (rb-cur) "^") (= (rb-cur) "~")
|
||||
(= (rb-cur) "|"))
|
||||
(do
|
||||
(let ((l line) (c col)) (rb-read-op! l c))
|
||||
(rb-scan!)))
|
||||
(:else (do (rb-advance!) (rb-scan!))))))
|
||||
(rb-scan!)
|
||||
(rb-push! "eof" nil line col)
|
||||
tokens)))
|
||||
81
plans/agent-briefings/apl-loop.md
Normal file
81
plans/agent-briefings/apl-loop.md
Normal file
@@ -0,0 +1,81 @@
|
||||
# apl-on-sx loop agent (single agent, queue-driven)
|
||||
|
||||
Role: iterates `plans/apl-on-sx.md` forever. Rank-polymorphic primitives + 6 operators on the JIT is the headline showcase — APL is the densest combinator algebra you can put on top of a primitive table. Every program is `array → array` pure pipelines, exactly what the JIT was built for.
|
||||
|
||||
```
|
||||
description: apl-on-sx queue loop
|
||||
subagent_type: general-purpose
|
||||
run_in_background: true
|
||||
isolation: worktree
|
||||
```
|
||||
|
||||
## Prompt
|
||||
|
||||
You are the sole background agent working `/root/rose-ash/plans/apl-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
|
||||
|
||||
## Restart baseline — check before iterating
|
||||
|
||||
1. Read `plans/apl-on-sx.md` — roadmap + Progress log.
|
||||
2. `ls lib/apl/` — pick up from the most advanced file.
|
||||
3. If `lib/apl/tests/*.sx` exist, run them. Green before new work.
|
||||
4. If `lib/apl/scoreboard.md` exists, that's your baseline.
|
||||
|
||||
## The queue
|
||||
|
||||
Phase order per `plans/apl-on-sx.md`:
|
||||
|
||||
- **Phase 1** — tokenizer + parser. Unicode glyphs, `¯` for negative, strands (juxtaposition), right-to-left, valence resolution by syntactic position
|
||||
- **Phase 2** — array model + scalar primitives. `make-array {shape, ravel}`, scalar promotion, broadcast for `+ - × ÷ ⌈ ⌊ * ⍟ | ! ○`, comparison, logical, `⍳`, `⎕IO`
|
||||
- **Phase 3** — structural primitives + indexing. `⍴ , ⍉ ↑ ↓ ⌽ ⊖ ⌷ ⍋ ⍒ ⊂ ⊃ ∊`
|
||||
- **Phase 4** — **THE SHOWCASE**: operators. `f/` (reduce), `f¨` (each), `∘.f` (outer), `f.g` (inner), `f⍨` (commute), `f∘g` (compose), `f⍣n` (power), `f⍤k` (rank), `@` (at)
|
||||
- **Phase 5** — dfns + tradfns + control flow. `{⍺+⍵}`, `∇` recurse, `⍺←default`, tradfn header, `:If/:While/:For/:Select`
|
||||
- **Phase 6** — classic programs (life, mandelbrot, primes, n-queens, quicksort) + idiom corpus + drive to 100+
|
||||
|
||||
Within a phase, pick the checkbox that unlocks the most tests per effort.
|
||||
|
||||
Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
|
||||
|
||||
## Ground rules (hard)
|
||||
|
||||
- **Scope:** only `lib/apl/**` and `plans/apl-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. APL primitives go in `lib/apl/runtime.sx`.
|
||||
- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
|
||||
- **Shared-file issues** → plan's Blockers with minimal repro.
|
||||
- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
|
||||
- **Unicode in `.sx`:** raw UTF-8 only, never `\uXXXX` escapes. Glyphs land directly in source.
|
||||
- **Worktree:** commit locally. Never push. Never touch `main`.
|
||||
- **Commit granularity:** one feature per commit.
|
||||
- **Plan file:** update Progress log + tick boxes every commit.
|
||||
|
||||
## APL-specific gotchas
|
||||
|
||||
- **Right-to-left, no precedence among functions.** `2 × 3 + 4` is `2 × (3 + 4)` = 14, not 10. Operators bind tighter than functions: `+/ ⍳5` is `+/(⍳5)`, and `2 +.× 3 4` is `2 (+.×) 3 4`.
|
||||
- **Valence by position.** `-3` is monadic negate (`-` with no left arg). `5-3` is dyadic subtract. The parser must look left to decide. Same glyph; different fn.
|
||||
- **`¯` is part of a number literal**, not a prefix function. `¯3` is the literal negative three; `-3` is the function call. Tokenizer eats `¯` into the numeric token.
|
||||
- **Strands.** `1 2 3` is a 3-element vector, not three separate calls. Adjacent literals fuse into a strand at parse time. Adjacent names do *not* fuse — `a b c` is three separate references.
|
||||
- **Scalar promotion.** `1 + 2 3 4` ↦ `3 4 5`. Any scalar broadcasts against any-rank conformable shape.
|
||||
- **Conformability** = exactly matching shapes, OR one side scalar, OR (in some dialects) one side rank-1 cycling against rank-N. Keep strict in v1: matching shape or scalar only.
|
||||
- **`⍳` is overloaded.** Monadic `⍳N` = vector 1..N (or 0..N-1 if `⎕IO=0`). Dyadic `V ⍳ W` = first-index lookup, returns `≢V+1` for not-found.
|
||||
- **Reduce with `+/⍳0`** = `0` (identity for `+`). Each scalar primitive has a defined identity used by reduce-on-empty. Don't crash; return identity.
|
||||
- **Reduce direction.** `f/` reduces the *last* axis. `f⌿` reduces the *first*. Matters for matrices.
|
||||
- **Indexing is 1-based** by default (`⎕IO=1`). Do not silently translate to 0-based; respect `⎕IO`.
|
||||
- **Bracket indexing** `A[I]` is sugar for `I⌷A` (squad-quad). Multi-axis: `A[I;J]` is `I J⌷A` with semicolon-separated axes; `A[;J]` selects all of axis 0.
|
||||
- **Dfn `{...}`** — `⍺` = left arg (may be unbound for monadic call → check with `⍺←default`), `⍵` = right arg, `∇` = recurse. Default left arg syntax: `⍺←0`.
|
||||
- **Tradfn vs dfn** — tradfns use line-numbered `→linenum` for goto; dfns use guards `cond:expr`. Pick the right one for the user's syntax.
|
||||
- **Empty array** = rank-N array where some dim is 0. `0⍴⍳0` is empty rank-1. Scalar prototype matters for empty-array operations; ignore in v1, return 0/space.
|
||||
- **Test corpus:** custom + idioms. Place programs in `lib/apl/tests/programs/` with `.apl` extension.
|
||||
|
||||
## General gotchas (all loops)
|
||||
|
||||
- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
|
||||
- `cond`/`when`/`let` clauses evaluate only the last expr.
|
||||
- `type-of` on user fn returns `"lambda"`.
|
||||
- Shell heredoc `||` gets eaten — escape or use `case`.
|
||||
|
||||
## Style
|
||||
|
||||
- No comments in `.sx` unless non-obvious.
|
||||
- No new planning docs — update `plans/apl-on-sx.md` inline.
|
||||
- Short, factual commit messages (`apl: outer product ∘. (+9)`).
|
||||
- One feature per iteration. Commit. Log. Next.
|
||||
|
||||
Go. Read the plan; find first `[ ]`; implement.
|
||||
80
plans/agent-briefings/common-lisp-loop.md
Normal file
80
plans/agent-briefings/common-lisp-loop.md
Normal file
@@ -0,0 +1,80 @@
|
||||
# common-lisp-on-sx loop agent (single agent, queue-driven)
|
||||
|
||||
Role: iterates `plans/common-lisp-on-sx.md` forever. Conditions + restarts on delimited continuations is the headline showcase — every other Lisp reinvents resumable exceptions on the host stack. On SX `signal`/`invoke-restart` is just a captured continuation. Plus CLOS, the LOOP macro, packages.
|
||||
|
||||
```
|
||||
description: common-lisp-on-sx queue loop
|
||||
subagent_type: general-purpose
|
||||
run_in_background: true
|
||||
isolation: worktree
|
||||
```
|
||||
|
||||
## Prompt
|
||||
|
||||
You are the sole background agent working `/root/rose-ash/plans/common-lisp-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
|
||||
|
||||
## Restart baseline — check before iterating
|
||||
|
||||
1. Read `plans/common-lisp-on-sx.md` — roadmap + Progress log.
|
||||
2. `ls lib/common-lisp/` — pick up from the most advanced file.
|
||||
3. If `lib/common-lisp/tests/*.sx` exist, run them. Green before new work.
|
||||
4. If `lib/common-lisp/scoreboard.md` exists, that's your baseline.
|
||||
|
||||
## The queue
|
||||
|
||||
Phase order per `plans/common-lisp-on-sx.md`:
|
||||
|
||||
- **Phase 1** — reader + parser (read macros `#'` `'` `` ` `` `,` `,@` `#( … )` `#:` `#\char` `#xFF` `#b1010`, ratios, dispatch chars, lambda lists with `&optional`/`&rest`/`&key`/`&aux`)
|
||||
- **Phase 2** — sequential eval + special forms (`let`/`let*`/`flet`/`labels`, `block`/`return-from`, `tagbody`/`go`, `unwind-protect`, multiple values, `setf` subset, dynamic variables)
|
||||
- **Phase 3** — **THE SHOWCASE**: condition system + restarts. `define-condition`, `signal`/`error`/`cerror`/`warn`, `handler-bind` (non-unwinding), `handler-case` (unwinding), `restart-case`, `restart-bind`, `find-restart`/`invoke-restart`/`compute-restarts`, `with-condition-restarts`. Classic programs (restart-demo, parse-recover, interactive-debugger) green.
|
||||
- **Phase 4** — CLOS: `defclass`, `defgeneric`, `defmethod` with `:before`/`:after`/`:around`, `call-next-method`, multiple dispatch
|
||||
- **Phase 5** — macros + LOOP macro + reader macros
|
||||
- **Phase 6** — packages + stdlib (sequence functions, FORMAT directives, drive corpus to 200+)
|
||||
|
||||
Within a phase, pick the checkbox that unlocks the most tests per effort.
|
||||
|
||||
Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
|
||||
|
||||
## Ground rules (hard)
|
||||
|
||||
- **Scope:** only `lib/common-lisp/**` and `plans/common-lisp-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. CL primitives go in `lib/common-lisp/runtime.sx`.
|
||||
- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
|
||||
- **Shared-file issues** → plan's Blockers with minimal repro.
|
||||
- **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5. `sx_summarise` spec/evaluator.sx first — 2300+ lines.
|
||||
- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
|
||||
- **Worktree:** commit locally. Never push. Never touch `main`.
|
||||
- **Commit granularity:** one feature per commit.
|
||||
- **Plan file:** update Progress log + tick boxes every commit.
|
||||
|
||||
## Common-Lisp-specific gotchas
|
||||
|
||||
- **`handler-bind` is non-unwinding** — handlers can decline by returning normally, in which case `signal` keeps walking the chain. **`handler-case` is unwinding** — picking a handler aborts the protected form via a captured continuation. Don't conflate them.
|
||||
- **Restarts are not handlers.** `restart-case` establishes named *resumption points*; `signal` runs handler code with restarts visible; the handler chooses a restart by calling `invoke-restart`, which abandons handler stack and resumes at the restart point. Two stacks: handlers walk down, restarts wait to be invoked.
|
||||
- **`block` / `return-from`** is lexical. `block name … (return-from name v) …` captures `^k` once at entry; `return-from` invokes it. `return-from` to a name not in scope is an error (don't fall back to outer block).
|
||||
- **`tagbody` / `go`** — each tag in tagbody is a continuation; `go tag` invokes it. Tags are lexical, can only target tagbodies in scope.
|
||||
- **`unwind-protect`** runs cleanup on *any* non-local exit (return-from, throw, condition unwind). Implement as a scope frame fired by the cleanup machinery.
|
||||
- **Multiple values**: primary-value-only contexts (function args, `if` test, etc.) drop extras silently. `values` produces multiple. `multiple-value-bind` / `multiple-value-call` consume them. Don't auto-list.
|
||||
- **CLOS dispatch:** sort applicable methods by argument-list specificity (`subclassp` per arg, left-to-right); standard method combination calls primary methods most-specific-first via `call-next-method` chain. `:before` runs all before primaries; `:after` runs all after, in reverse-specificity. `:around` wraps everything.
|
||||
- **`call-next-method`** is a *continuation* available only inside a method body. Implement as a thunk stored in a dynamic-extent variable.
|
||||
- **Generalised reference (`setf`)**: `(setf (foo x) v)` ↦ `(setf-foo v x)`. Look up the setf-expander, not just a writer fn. `define-setf-expander` is mandatory for non-trivial places. Start with the symbolic / list / aref / slot-value cases.
|
||||
- **Dynamic variables (specials):** `defvar`/`defparameter` mark a symbol as special. `let` over a special name *rebinds* in dynamic extent (use parameterize-style scope), not lexical.
|
||||
- **Symbols are package-qualified.** Reader resolves `cl:car`, `mypkg::internal`, bare `foo` (current package). Internal vs external matters for `:` (one colon) reads.
|
||||
- **`nil` is also `()` is also the empty list.** Same object. `nil` is also false. CL has no distinct unit value.
|
||||
- **LOOP macro is huge.** Build incrementally — start with `for/in`, `for/from`, `collect`, `sum`, `count`, `repeat`. Add conditional clauses (`when`, `if`, `else`) once iteration drivers stable. `named` blocks + `return-from named` last.
|
||||
- **Test corpus:** custom + curated `ansi-test` slice. Place programs in `lib/common-lisp/tests/programs/` with `.lisp` extension.
|
||||
|
||||
## General gotchas (all loops)
|
||||
|
||||
- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
|
||||
- `cond`/`when`/`let` clauses evaluate only the last expr.
|
||||
- `type-of` on user fn returns `"lambda"`.
|
||||
- Shell heredoc `||` gets eaten — escape or use `case`.
|
||||
|
||||
## Style
|
||||
|
||||
- No comments in `.sx` unless non-obvious.
|
||||
- No new planning docs — update `plans/common-lisp-on-sx.md` inline.
|
||||
- Short, factual commit messages (`common-lisp: handler-bind + 12 tests`).
|
||||
- One feature per iteration. Commit. Log. Next.
|
||||
|
||||
Go. Read the plan; find first `[ ]`; implement.
|
||||
83
plans/agent-briefings/ruby-loop.md
Normal file
83
plans/agent-briefings/ruby-loop.md
Normal file
@@ -0,0 +1,83 @@
|
||||
# ruby-on-sx loop agent (single agent, queue-driven)
|
||||
|
||||
Role: iterates `plans/ruby-on-sx.md` forever. Fibers via delcc is the headline showcase — `Fiber.new`/`Fiber.yield`/`Fiber.resume` are textbook delimited continuations with sugar, where MRI does it via C-stack swapping. Plus blocks/yield (lexical escape continuations, same shape as Smalltalk's non-local return), method_missing, and singleton classes.
|
||||
|
||||
```
|
||||
description: ruby-on-sx queue loop
|
||||
subagent_type: general-purpose
|
||||
run_in_background: true
|
||||
isolation: worktree
|
||||
```
|
||||
|
||||
## Prompt
|
||||
|
||||
You are the sole background agent working `/root/rose-ash/plans/ruby-on-sx.md`. Isolated worktree, forever, one commit per feature. Push to `origin/loops/ruby` after every commit.
|
||||
|
||||
## Restart baseline — check before iterating
|
||||
|
||||
1. Read `plans/ruby-on-sx.md` — roadmap + Progress log.
|
||||
2. `ls lib/ruby/` — pick up from the most advanced file.
|
||||
3. If `lib/ruby/tests/*.sx` exist, run them. Green before new work.
|
||||
4. If `lib/ruby/scoreboard.md` exists, that's your baseline.
|
||||
|
||||
## The queue
|
||||
|
||||
Phase order per `plans/ruby-on-sx.md`:
|
||||
|
||||
- **Phase 1** — tokenizer + parser. Keywords, identifier sigils (`@` ivar, `@@` cvar, `$` global), strings with interpolation, `%w[]`/`%i[]`, symbols, blocks `{|x| …}` and `do |x| … end`, splats, default args, method def
|
||||
- **Phase 2** — object model + sequential eval. Class table, ancestor-chain dispatch, `super`, singleton classes, `method_missing` fallback, dynamic constant lookup
|
||||
- **Phase 3** — blocks + procs + lambdas. Method captures escape continuation `^k`; `yield` / `return` / `break` / `next` / `redo` semantics; lambda strict arity vs proc lax
|
||||
- **Phase 4** — **THE SHOWCASE**: fibers via delcc. `Fiber.new`/`Fiber.resume`/`Fiber.yield`/`Fiber.transfer`. Classic programs (generator, producer-consumer, tree-walk) green
|
||||
- **Phase 5** — modules + mixins + metaprogramming. `include`/`prepend`/`extend`, `define_method`, `class_eval`/`instance_eval`, `respond_to?`/`respond_to_missing?`, hooks
|
||||
- **Phase 6** — stdlib drive. `Enumerable` mixin, `Comparable`, Array/Hash/Range/String/Integer methods, drive corpus to 200+
|
||||
|
||||
Within a phase, pick the checkbox that unlocks the most tests per effort.
|
||||
|
||||
Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
|
||||
|
||||
## Ground rules (hard)
|
||||
|
||||
- **Scope:** only `lib/ruby/**` and `plans/ruby-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. Ruby primitives go in `lib/ruby/runtime.sx`.
|
||||
- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
|
||||
- **Shared-file issues** → plan's Blockers with minimal repro.
|
||||
- **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5. `sx_summarise` spec/evaluator.sx first — 2300+ lines.
|
||||
- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
|
||||
- **Worktree:** commit, then push to `origin/loops/ruby`. Never touch `main`.
|
||||
- **Commit granularity:** one feature per commit.
|
||||
- **Plan file:** update Progress log + tick boxes every commit.
|
||||
|
||||
## Ruby-specific gotchas
|
||||
|
||||
- **Block `return` vs lambda `return`.** Inside a block `{ ... return v }`, `return` invokes the *enclosing method's* escape continuation (non-local return). Inside a lambda `->(){ ... return v }`, `return` returns from the *lambda*. Don't conflate. Implement: blocks bind their `^method-k`; lambdas bind their own `^lambda-k`.
|
||||
- **`break` from inside a block** invokes a different escape — the *iteration loop's* escape — and the loop returns the break-value. `next` is escape from current iteration, returns iteration value. `redo` re-enters current iteration without advancing.
|
||||
- **Proc arity is lax.** `proc { |a, b, c| … }.call(1, 2)` ↦ `c = nil`. Lambda is strict — same call raises ArgumentError. Check arity at call site for lambdas only.
|
||||
- **Block argument unpacking.** `[[1,2],[3,4]].each { |a, b| … }` — single Array arg auto-unpacks for blocks (not lambdas). One arg, one Array → unpack. Frequent footgun.
|
||||
- **Method dispatch chain order:** prepended modules → class methods → included modules → superclass → BasicObject → method_missing. `super` walks from the *defining* class's position, not the receiver class's.
|
||||
- **Singleton classes** are lazily allocated. Looking up the chain for an object passes through its singleton class first, then its actual class. `class << obj; …; end` opens the singleton.
|
||||
- **`method_missing`** — fallback when ancestor walk misses. Receives `(name_symbol, *args, &blk)`. Pair with `respond_to_missing?` for `respond_to?` to also report true. Do **not** swallow NoMethodError silently.
|
||||
- **Ivars are per-object dicts.** Reading an unset ivar yields `nil` and a warning (`-W`). Don't error.
|
||||
- **Constant lookup** is first lexical (Module.nesting), then inheritance (Module.ancestors of the innermost class). Different from method lookup.
|
||||
- **`Object#send`** invokes private and public methods alike; `Object#public_send` skips privates.
|
||||
- **Class reopening.** `class Foo; def bar; …; end; end` plus a later `class Foo; def baz; …; end; end` adds methods to the same class. Class table lookups must be by-name, mutable; methods dict is mutable.
|
||||
- **Fiber semantics.** `Fiber.new { |arg| … }` creates a fiber suspended at entry. First `Fiber.resume(v)` enters with `arg = v`. Inside, `Fiber.yield(w)` returns `w` to the resumer; the next `Fiber.resume(v')` returns `v'` to the yield site. End of block returns final value to last resumer; subsequent `Fiber.resume` raises FiberError.
|
||||
- **`Fiber.transfer`** is symmetric — either side can transfer to the other; no resume/yield asymmetry. Implement on top of the same continuation pair, just don't enforce direction.
|
||||
- **Symbols are interned.** `:foo == :foo` is identity. Use SX symbols.
|
||||
- **Strings are mutable.** `s = "abc"; s << "d"; s == "abcd"`. Hash keys can be strings; hash dups string keys at insertion to be safe (or freeze them).
|
||||
- **Truthiness:** only `false` and `nil` are falsy. `0`, `""`, `[]` are truthy.
|
||||
- **Test corpus:** custom + curated RubySpec slice. Place programs in `lib/ruby/tests/programs/` with `.rb` extension.
|
||||
|
||||
## General gotchas (all loops)
|
||||
|
||||
- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
|
||||
- `cond`/`when`/`let` clauses evaluate only the last expr.
|
||||
- `type-of` on user fn returns `"lambda"`.
|
||||
- Shell heredoc `||` gets eaten — escape or use `case`.
|
||||
|
||||
## Style
|
||||
|
||||
- No comments in `.sx` unless non-obvious.
|
||||
- No new planning docs — update `plans/ruby-on-sx.md` inline.
|
||||
- Short, factual commit messages (`ruby: Fiber.yield + Fiber.resume (+8)`).
|
||||
- One feature per iteration. Commit. Log. Next.
|
||||
|
||||
Go. Read the plan; find first `[ ]`; implement.
|
||||
77
plans/agent-briefings/smalltalk-loop.md
Normal file
77
plans/agent-briefings/smalltalk-loop.md
Normal file
@@ -0,0 +1,77 @@
|
||||
# smalltalk-on-sx loop agent (single agent, queue-driven)
|
||||
|
||||
Role: iterates `plans/smalltalk-on-sx.md` forever. Message-passing OO + **blocks with non-local return** on delimited continuations. Non-local return is the headline showcase — every other Smalltalk reinvents it on the host stack; on SX it falls out of the captured method-return continuation.
|
||||
|
||||
```
|
||||
description: smalltalk-on-sx queue loop
|
||||
subagent_type: general-purpose
|
||||
run_in_background: true
|
||||
isolation: worktree
|
||||
```
|
||||
|
||||
## Prompt
|
||||
|
||||
You are the sole background agent working `/root/rose-ash/plans/smalltalk-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
|
||||
|
||||
## Restart baseline — check before iterating
|
||||
|
||||
1. Read `plans/smalltalk-on-sx.md` — roadmap + Progress log.
|
||||
2. `ls lib/smalltalk/` — pick up from the most advanced file.
|
||||
3. If `lib/smalltalk/tests/*.sx` exist, run them. Green before new work.
|
||||
4. If `lib/smalltalk/scoreboard.md` exists, that's your baseline.
|
||||
|
||||
## The queue
|
||||
|
||||
Phase order per `plans/smalltalk-on-sx.md`:
|
||||
|
||||
- **Phase 1** — tokenizer + parser (chunk format, identifiers, keywords `foo:`, binary selectors, `#sym`, `#(…)`, `$c`, blocks `[:a | …]`, cascades, message precedence)
|
||||
- **Phase 2** — object model + sequential eval (class table bootstrap, message dispatch, `super`, `doesNotUnderstand:`, instance variables)
|
||||
- **Phase 3** — **THE SHOWCASE**: blocks with non-local return via captured method-return continuation. `whileTrue:` / `ifTrue:ifFalse:` as block sends. 5 classic programs (eight-queens, quicksort, mandelbrot, life, fibonacci) green.
|
||||
- **Phase 4** — reflection + MOP: `perform:`, `respondsTo:`, runtime method addition, `becomeForward:`, `Exception` / `on:do:` / `ensure:` on top of `handler-bind`/`raise`
|
||||
- **Phase 5** — collections + numeric tower + streams
|
||||
- **Phase 6** — port SUnit, vendor Pharo Kernel-Tests slice, drive corpus to 200+
|
||||
- **Phase 7** — speed (optional): inline caching, block intrinsification
|
||||
|
||||
Within a phase, pick the checkbox that unlocks the most tests per effort.
|
||||
|
||||
Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
|
||||
|
||||
## Ground rules (hard)
|
||||
|
||||
- **Scope:** only `lib/smalltalk/**` and `plans/smalltalk-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. Smalltalk primitives go in `lib/smalltalk/runtime.sx`.
|
||||
- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
|
||||
- **Shared-file issues** → plan's Blockers with minimal repro.
|
||||
- **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5. `sx_summarise` spec/evaluator.sx first — 2300+ lines.
|
||||
- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
|
||||
- **Worktree:** commit locally. Never push. Never touch `main`.
|
||||
- **Commit granularity:** one feature per commit.
|
||||
- **Plan file:** update Progress log + tick boxes every commit.
|
||||
|
||||
## Smalltalk-specific gotchas
|
||||
|
||||
- **Method invocation captures `^k`** — the return continuation. Bind it as the block's escape token. `^expr` from inside any nested block invokes that captured `^k`. Escape past method return raises `BlockContext>>cannotReturn:`.
|
||||
- **Blocks are lambdas + escape token**, not bare lambdas. `value`/`value:`/… invoke the lambda; `^` invokes the escape.
|
||||
- **`ifTrue:` / `ifFalse:` / `whileTrue:` are ordinary block sends** — no special form. The runtime intrinsifies them in the JIT path (Tier 1 of bytecode expansion already covers this pattern).
|
||||
- **Cascade** `r m1; m2; m3` desugars to `(let ((tmp r)) (st-send tmp 'm1 ()) (st-send tmp 'm2 ()) (st-send tmp 'm3 ()))`. Result is the cascade's last send (or first, depending on parser variant — pick one and document).
|
||||
- **`super` send** looks up starting from the *defining* class's superclass, not the receiver class. Stash the defining class on the method record.
|
||||
- **Selectors are interned symbols.** Use SX symbols.
|
||||
- **Receiver dispatch:** tagged ints / floats / strings / symbols / `nil` / `true` / `false` aren't boxed. Their classes (`SmallInteger`, `Float`, `String`, `Symbol`, `UndefinedObject`, `True`, `False`) are looked up by SX type-of, not by an `:class` field.
|
||||
- **Method precedence:** unary > binary > keyword. `3 + 4 factorial` is `3 + (4 factorial)`. `a foo: b bar` is `a foo: (b bar)` (keyword absorbs trailing unary).
|
||||
- **Image / fileIn / become: between sessions** = out of scope. One-way `becomeForward:` only.
|
||||
- **Test corpus:** ~200 hand-written + a slice of Pharo Kernel-Tests. Place programs in `lib/smalltalk/tests/programs/`.
|
||||
|
||||
## General gotchas (all loops)
|
||||
|
||||
- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
|
||||
- `cond`/`when`/`let` clauses evaluate only the last expr.
|
||||
- `type-of` on user fn returns `"lambda"`.
|
||||
- Shell heredoc `||` gets eaten — escape or use `case`.
|
||||
|
||||
## Style
|
||||
|
||||
- No comments in `.sx` unless non-obvious.
|
||||
- No new planning docs — update `plans/smalltalk-on-sx.md` inline.
|
||||
- Short, factual commit messages (`smalltalk: tokenizer + 56 tests`).
|
||||
- One feature per iteration. Commit. Log. Next.
|
||||
|
||||
Go. Read the plan; find first `[ ]`; implement.
|
||||
83
plans/agent-briefings/tcl-loop.md
Normal file
83
plans/agent-briefings/tcl-loop.md
Normal file
@@ -0,0 +1,83 @@
|
||||
# tcl-on-sx loop agent (single agent, queue-driven)
|
||||
|
||||
Role: iterates `plans/tcl-on-sx.md` forever. `uplevel`/`upvar` is the headline showcase — Tcl's superpower for defining your own control structures, requiring deep VM cooperation in any normal host but falling out of SX's first-class env-chain. Plus the Dodekalogue (12 rules), command-substitution everywhere, and "everything is a string" homoiconicity.
|
||||
|
||||
```
|
||||
description: tcl-on-sx queue loop
|
||||
subagent_type: general-purpose
|
||||
run_in_background: true
|
||||
isolation: worktree
|
||||
```
|
||||
|
||||
## Prompt
|
||||
|
||||
You are the sole background agent working `/root/rose-ash/plans/tcl-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
|
||||
|
||||
## Restart baseline — check before iterating
|
||||
|
||||
1. Read `plans/tcl-on-sx.md` — roadmap + Progress log.
|
||||
2. `ls lib/tcl/` — pick up from the most advanced file.
|
||||
3. If `lib/tcl/tests/*.sx` exist, run them. Green before new work.
|
||||
4. If `lib/tcl/scoreboard.md` exists, that's your baseline.
|
||||
|
||||
## The queue
|
||||
|
||||
Phase order per `plans/tcl-on-sx.md`:
|
||||
|
||||
- **Phase 1** — tokenizer + parser. The Dodekalogue (12 rules): word-splitting, command sub `[…]`, var sub `$name`/`${name}`/`$arr(idx)`, double-quote vs brace word, backslash, `;`, `#` comments only at command start, single-pass left-to-right substitution
|
||||
- **Phase 2** — sequential eval + core commands. `set`/`unset`/`incr`/`append`/`lappend`, `puts`/`gets`, `expr` (own mini-language), `if`/`while`/`for`/`foreach`/`switch`, string commands, list commands, dict commands
|
||||
- **Phase 3** — **THE SHOWCASE**: `proc` + `uplevel` + `upvar`. Frame stack with proc-call push/pop; `uplevel #N script` evaluates in caller's frame; `upvar` aliases names across frames. Classic programs (for-each-line, assert macro, with-temp-var) green
|
||||
- **Phase 4** — `return -code N`, `catch`, `try`/`trap`/`finally`, `throw`. Control flow as integer codes
|
||||
- **Phase 5** — namespaces + ensembles. `namespace eval`, qualified names `::ns::cmd`, ensembles, `namespace path`
|
||||
- **Phase 6** — coroutines (built on fibers, same delcc as Ruby fibers) + system commands + drive corpus to 150+
|
||||
|
||||
Within a phase, pick the checkbox that unlocks the most tests per effort.
|
||||
|
||||
Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
|
||||
|
||||
## Ground rules (hard)
|
||||
|
||||
- **Scope:** only `lib/tcl/**` and `plans/tcl-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. Tcl primitives go in `lib/tcl/runtime.sx`.
|
||||
- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
|
||||
- **Shared-file issues** → plan's Blockers with minimal repro.
|
||||
- **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5. `sx_summarise` spec/evaluator.sx first — 2300+ lines.
|
||||
- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
|
||||
- **Worktree:** commit locally. Never push. Never touch `main`.
|
||||
- **Commit granularity:** one feature per commit.
|
||||
- **Plan file:** update Progress log + tick boxes every commit.
|
||||
|
||||
## Tcl-specific gotchas
|
||||
|
||||
- **Everything is a string.** Internally cache shimmer reps (list, dict, int, double) for performance, but every value must be re-stringifiable. Mutating one rep dirties the cached string and vice versa.
|
||||
- **The Dodekalogue is strict.** Substitution is **one-pass**, **left-to-right**. The result of a substitution is a value, not a script — it does NOT get re-parsed for further substitutions. This is what makes Tcl safe-by-default. Don't accidentally re-parse.
|
||||
- **Brace word `{…}`** is the only way to defer evaluation. No substitution inside, just balanced braces. Used for `if {expr}` body, `proc body`, `expr` arguments.
|
||||
- **Double-quote word `"…"`** is identical to a bare word for substitution purposes — it just allows whitespace in a single word. `\` escapes still apply.
|
||||
- **Comments are only at command position.** `# this is a comment` after a `;` or newline; *not* inside a command. `set x 1 # not a comment` is a 4-arg `set`.
|
||||
- **`expr` has its own grammar** — operator precedence, function calls — and does its own substitution. Brace `expr {$x + 1}` to avoid double-substitution and to enable bytecode caching.
|
||||
- **`if` and `while` re-parse** the condition only if not braced. Always use `if {…}`/`while {…}` form. The unbraced form re-substitutes per iteration.
|
||||
- **`return` from a `proc`** uses control code 2. `break` is 3, `continue` is 4. `error` is 1. `catch` traps any non-zero code; user can return non-zero with `return -code error -errorcode FOO message`.
|
||||
- **`uplevel #0 script`** is global frame. `uplevel 1 script` (or just `uplevel script`) is caller's frame. `uplevel #N` is absolute level N (0=global, 1=top-level proc, 2=proc-called-from-top, …). Negative levels are errors.
|
||||
- **`upvar #N otherVar localVar`** binds `localVar` in the current frame as an *alias* — both names refer to the same storage. Reads and writes go through the alias.
|
||||
- **`info level`** with no arg returns current level number. `info level N` (positive) returns the command list that invoked level N. `info level -N` returns the command list of the level N relative-up.
|
||||
- **Variable names with `(…)`** are array elements: `set arr(foo) 1`. Arrays are not first-class values — you can't `set x $arr`. `array get arr` gives a flat list `{key1 val1 key2 val2 …}`.
|
||||
- **List vs string.** `set l "a b c"` and `set l [list a b c]` look the same when printed but the second has a cached list rep. `lindex` works on both via shimmering. Most user code can't tell the difference.
|
||||
- **`incr x`** errors if x doesn't exist; pre-set with `set x 0` or use `incr x 0` first if you mean "create-or-increment". Or use `dict incr` for dicts.
|
||||
- **Coroutines are fibers.** `coroutine name body` starts a coroutine; calling `name` resumes it; `yield value` from inside suspends and returns `value` to the resumer. Same primitive as Ruby fibers — share the implementation under the hood.
|
||||
- **`switch`** matches first clause whose pattern matches. Default is `default`. Variant matches: glob (default), `-exact`, `-glob`, `-regexp`. Body `-` means "fall through to next clause's body".
|
||||
- **Test corpus:** custom + slice of Tcl's own tests. Place programs in `lib/tcl/tests/programs/` with `.tcl` extension.
|
||||
|
||||
## General gotchas (all loops)
|
||||
|
||||
- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
|
||||
- `cond`/`when`/`let` clauses evaluate only the last expr.
|
||||
- `type-of` on user fn returns `"lambda"`.
|
||||
- Shell heredoc `||` gets eaten — escape or use `case`.
|
||||
|
||||
## Style
|
||||
|
||||
- No comments in `.sx` unless non-obvious.
|
||||
- No new planning docs — update `plans/tcl-on-sx.md` inline.
|
||||
- Short, factual commit messages (`tcl: uplevel + upvar (+11)`).
|
||||
- One feature per iteration. Commit. Log. Next.
|
||||
|
||||
Go. Read the plan; find first `[ ]`; implement.
|
||||
115
plans/apl-on-sx.md
Normal file
115
plans/apl-on-sx.md
Normal file
@@ -0,0 +1,115 @@
|
||||
# APL-on-SX: rank-polymorphic primitives + glyph parser
|
||||
|
||||
The headline showcase is **rank polymorphism** — a single primitive (`+`, `⌈`, `⊂`, `⍳`) works uniformly on scalars, vectors, matrices, and higher-rank arrays. ~80 glyph primitives + 6 operators bind together with right-to-left evaluation; the entire language is a high-density combinator algebra. The JIT compiler + primitive table pay off massively here because almost every program is `array → array` pure pipelines.
|
||||
|
||||
End-state goal: Dyalog-flavoured APL subset, dfns + tradfns, classic programs (game-of-life, mandelbrot, prime-sieve, n-queens, conway), 100+ green tests.
|
||||
|
||||
## Scope decisions (defaults — override by editing before we spawn)
|
||||
|
||||
- **Syntax:** Dyalog APL surface, Unicode glyphs. `⎕`-quad system functions for I/O. `∇` tradfn header.
|
||||
- **Conformance:** "Reads like APL, runs like APL." Not byte-compat with Dyalog; we care about right-to-left semantics and rank polymorphism.
|
||||
- **Test corpus:** custom — APL idioms (Roger Hui style), classic programs, plus ~50 pattern tests for primitives.
|
||||
- **Out of scope:** ⎕-namespaces beyond a handful, complex numbers, full TAO ordering, `⎕FX` runtime function definition (use static `∇` only), nested-array-of-functions higher orders, the editor.
|
||||
- **Glyphs:** input via plain Unicode in `.apl` source files. Backtick-prefix shortcuts handled by the user's editor — we don't ship one.
|
||||
|
||||
## Ground rules
|
||||
|
||||
- **Scope:** only touch `lib/apl/**` and `plans/apl-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. APL primitives go in `lib/apl/runtime.sx`.
|
||||
- **SX files:** use `sx-tree` MCP tools only.
|
||||
- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
|
||||
|
||||
## Architecture sketch
|
||||
|
||||
```
|
||||
APL source (Unicode glyphs)
|
||||
│
|
||||
▼
|
||||
lib/apl/tokenizer.sx — glyphs, identifiers, numbers (¯ for negative), strings, strands
|
||||
│
|
||||
▼
|
||||
lib/apl/parser.sx — right-to-left with valence resolution (mon vs dyadic by position)
|
||||
│
|
||||
▼
|
||||
lib/apl/transpile.sx — AST → SX AST (entry: apl-eval-ast)
|
||||
│
|
||||
▼
|
||||
lib/apl/runtime.sx — array model, ~80 primitives, 6 operators, dfns/tradfns
|
||||
```
|
||||
|
||||
Core mapping:
|
||||
- **Array** = SX dict `{:shape (d1 d2 …) :ravel #(v1 v2 …)}`. Scalar is rank-0 (empty shape), vector is rank-1, matrix rank-2, etc. Type uniformity not required (heterogeneous nested arrays via "boxed" elements `⊂x`).
|
||||
- **Rank polymorphism** — every scalar primitive is broadcast: `1 2 3 + 4 5 6` ↦ `5 7 9`; `(2 3⍴⍳6) + 1` ↦ broadcast scalar to matrix.
|
||||
- **Conformability** = matching shapes, or one-side scalar, or rank-1 cycling (deferred — keep strict in v1).
|
||||
- **Valence** = each glyph has a monadic and a dyadic meaning; resolution is purely positional (left-arg present → dyadic).
|
||||
- **Operator** = takes one or two function operands, returns a derived function (`f¨` = `each f`, `f/` = `reduce f`, `f∘g` = `compose`, `f⍨` = `commute`).
|
||||
- **Tradfn** `∇R←L F R; locals` = named function with explicit header.
|
||||
- **Dfn** `{⍺+⍵}` = anonymous, `⍺` = left arg, `⍵` = right arg, `∇` = recurse.
|
||||
|
||||
## Roadmap
|
||||
|
||||
### Phase 1 — tokenizer + parser
|
||||
- [ ] Tokenizer: Unicode glyphs (the full APL set: `+ - × ÷ * ⍟ ⌈ ⌊ | ! ? ○ ~ < ≤ = ≥ > ≠ ∊ ∧ ∨ ⍱ ⍲ , ⍪ ⍴ ⌽ ⊖ ⍉ ↑ ↓ ⊂ ⊃ ⊆ ∪ ∩ ⍳ ⍸ ⌷ ⍋ ⍒ ⊥ ⊤ ⊣ ⊢ ⍎ ⍕ ⍝`), operators (`/ \ ¨ ⍨ ∘ . ⍣ ⍤ ⍥ @`), numbers (`¯` for negative, `1E2`, `1J2` complex deferred), characters (`'a'`, `''` escape), strands (juxtaposition of literals: `1 2 3`), names, comments `⍝ …`
|
||||
- [ ] Parser: right-to-left; classify each token as function, operator, value, or name; resolve valence positionally; dfn `{…}` body, tradfn `∇` header, guards `:`, control words `:If :While :For …` (Dyalog-style)
|
||||
- [ ] Unit tests in `lib/apl/tests/parse.sx`
|
||||
|
||||
### Phase 2 — array model + scalar primitives
|
||||
- [ ] Array constructor: `make-array shape ravel`, `scalar v`, `vector v…`, `enclose`/`disclose`
|
||||
- [ ] Shape arithmetic: `⍴` (shape), `,` (ravel), `≢` (tally / first-axis-length), `≡` (depth)
|
||||
- [ ] Scalar arithmetic primitives broadcast: `+ - × ÷ ⌈ ⌊ * ⍟ | ! ○`
|
||||
- [ ] Scalar comparison primitives: `< ≤ = ≥ > ≠`
|
||||
- [ ] Scalar logical: `~ ∧ ∨ ⍱ ⍲`
|
||||
- [ ] Index generator: `⍳n` (vector 1..n or 0..n-1 depending on `⎕IO`)
|
||||
- [ ] `⎕IO` = 1 default (Dyalog convention)
|
||||
- [ ] 40+ tests in `lib/apl/tests/scalar.sx`
|
||||
|
||||
### Phase 3 — structural primitives + indexing
|
||||
- [ ] Reshape `⍴`, ravel `,`, transpose `⍉` (full + dyadic axis spec)
|
||||
- [ ] Take `↑`, drop `↓`, rotate `⌽` (last axis), `⊖` (first axis)
|
||||
- [ ] Catenate `,` (last axis) and `⍪` (first axis)
|
||||
- [ ] Index `⌷` (squad), bracket-indexing `A[I]` (sugar for `⌷`)
|
||||
- [ ] Grade-up `⍋`, grade-down `⍒`
|
||||
- [ ] Enclose `⊂`, disclose `⊃`, partition (subset deferred)
|
||||
- [ ] Membership `∊`, find `⍳` (dyadic), without `~` (dyadic), unique `∪` (deferred to phase 6)
|
||||
- [ ] 40+ tests in `lib/apl/tests/structural.sx`
|
||||
|
||||
### Phase 4 — operators (THE SHOWCASE)
|
||||
- [ ] Reduce `f/` (last axis), `f⌿` (first axis) — including `∧/`, `∨/`, `+/`, `×/`, `⌈/`, `⌊/`
|
||||
- [ ] Scan `f\`, `f⍀`
|
||||
- [ ] Each `f¨` — applies `f` to each scalar/element
|
||||
- [ ] Outer product `∘.f` — `1 2 3 ∘.× 1 2 3` ↦ multiplication table
|
||||
- [ ] Inner product `f.g` — `+.×` is matrix multiply
|
||||
- [ ] Commute `f⍨` — `f⍨ x` ↔ `x f x`, `x f⍨ y` ↔ `y f x`
|
||||
- [ ] Compose `f∘g` — applies `g` first then `f`
|
||||
- [ ] Power `f⍣n` — apply f n times; `f⍣≡` until fixed point
|
||||
- [ ] Rank `f⍤k` — apply f at sub-rank k
|
||||
- [ ] At `@` — selective replace
|
||||
- [ ] 40+ tests in `lib/apl/tests/operators.sx`
|
||||
|
||||
### Phase 5 — dfns + tradfns + control flow
|
||||
- [ ] Dfn `{…}` with `⍺` (left arg, may be absent → niladic/monadic), `⍵` (right arg), `∇` (recurse), guards `cond:expr`, default left arg `⍺←default`
|
||||
- [ ] Local assignment via `←` (lexical inside dfn)
|
||||
- [ ] Tradfn `∇` header: `R←L F R;l1;l2`, statement-by-statement, branch via `→linenum`
|
||||
- [ ] Dyalog control words: `:If/:Else/:EndIf`, `:While/:EndWhile`, `:For X :In V :EndFor`, `:Select/:Case/:EndSelect`, `:Trap`/`:EndTrap`
|
||||
- [ ] Niladic / monadic / dyadic dispatch (function valence at definition time)
|
||||
- [ ] `lib/apl/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
|
||||
|
||||
### Phase 6 — classic programs + drive corpus
|
||||
- [ ] Classic programs in `lib/apl/tests/programs/`:
|
||||
- [ ] `life.apl` — Conway's Game of Life as a one-liner using `⊂` `⊖` `⌽` `+/`
|
||||
- [ ] `mandelbrot.apl` — complex iteration with rank-polymorphic `+ × ⌊` (or real-axis subset)
|
||||
- [ ] `primes.apl` — `(2=+⌿0=A∘.|A)/A←⍳N` sieve
|
||||
- [ ] `n-queens.apl` — backtracking via reduce
|
||||
- [ ] `quicksort.apl` — the classic Roger Hui one-liner
|
||||
- [ ] System functions: `⎕FMT`, `⎕FR` (float repr), `⎕TS` (timestamp), `⎕IO`, `⎕ML` (migration level — fixed at 1), `⎕←` (print)
|
||||
- [ ] Drive corpus to 100+ green
|
||||
- [ ] Idiom corpus — `lib/apl/tests/idioms.sx` covering classic Roger Hui / Phil Last idioms
|
||||
|
||||
## Progress log
|
||||
|
||||
_Newest first._
|
||||
|
||||
- _(none yet)_
|
||||
|
||||
## Blockers
|
||||
|
||||
- _(none yet)_
|
||||
121
plans/common-lisp-on-sx.md
Normal file
121
plans/common-lisp-on-sx.md
Normal file
@@ -0,0 +1,121 @@
|
||||
# Common-Lisp-on-SX: conditions + restarts on delimited continuations
|
||||
|
||||
The headline showcase is the **condition system**. Restarts are *resumable* exceptions — every other Lisp implementation reinvents this on host-stack unwind tricks. On SX restarts are textbook delimited continuations: `signal` walks the handler chain; `invoke-restart` resumes the captured continuation at the restart point. Same delcc primitive that powers Erlang actors, expressed as a different surface.
|
||||
|
||||
End-state goal: ANSI Common Lisp subset with a working condition/restart system, CLOS multimethods (with `:before`/`:after`/`:around`), the LOOP macro, packages, and ~150 hand-written + classic programs.
|
||||
|
||||
## Scope decisions (defaults — override by editing before we spawn)
|
||||
|
||||
- **Syntax:** ANSI Common Lisp surface. Read tables, dispatch macros (`#'`, `#(`, `#\`, `#:`, `#x`, `#b`, `#o`, ratios `1/3`).
|
||||
- **Conformance:** ANSI X3.226 *as a target*, not bug-for-bug SBCL/CCL. "Reads like CL, runs like CL."
|
||||
- **Test corpus:** custom + a curated slice of `ansi-test`. Plus classic programs: condition-system demo, restart-driven debugger, multiple-dispatch geometry, LOOP corpus.
|
||||
- **Out of scope:** compilation to native, FFI, sockets, threads, MOP class redefinition, full pathname/logical-pathname machinery, structures with `:include` deep customization.
|
||||
- **Packages:** simple — `defpackage`/`in-package`/`export`/`use-package`/`:cl`/`:cl-user`. No nicknames, no shadowing-import edge cases.
|
||||
|
||||
## Ground rules
|
||||
|
||||
- **Scope:** only touch `lib/common-lisp/**` and `plans/common-lisp-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. CL primitives go in `lib/common-lisp/runtime.sx`.
|
||||
- **SX files:** use `sx-tree` MCP tools only.
|
||||
- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
|
||||
|
||||
## Architecture sketch
|
||||
|
||||
```
|
||||
Common Lisp source
|
||||
│
|
||||
▼
|
||||
lib/common-lisp/reader.sx — tokenizer + reader (read macros, dispatch chars)
|
||||
│
|
||||
▼
|
||||
lib/common-lisp/parser.sx — AST: forms, declarations, lambda lists
|
||||
│
|
||||
▼
|
||||
lib/common-lisp/transpile.sx — AST → SX AST (entry: cl-eval-ast)
|
||||
│
|
||||
▼
|
||||
lib/common-lisp/runtime.sx — special forms, condition system, CLOS, packages, BIFs
|
||||
```
|
||||
|
||||
Core mapping:
|
||||
- **Symbol** = SX symbol with package prefix; package table is a flat dict.
|
||||
- **Cons cell** = SX pair via `cons`/`car`/`cdr`; lists native.
|
||||
- **Multiple values** = thread through `values`/`multiple-value-bind`; primary-value default for one-context callers.
|
||||
- **Block / return-from** = captured continuation; `return-from name v` invokes the block-named `^k`.
|
||||
- **Tagbody / go** = each tag is a continuation; `go tag` invokes it.
|
||||
- **Unwind-protect** = scope frame with a cleanup thunk fired on any non-local exit.
|
||||
- **Conditions / restarts** = layered handler chain on top of `handler-bind` + delcc. `signal` walks handlers; `invoke-restart` resumes a captured continuation.
|
||||
- **CLOS** = generic functions are dispatch tables on argument-class lists; method combination computed lazily; `call-next-method` is a continuation.
|
||||
- **Macros** = SX macros (sentinel-body) — defmacro lowers directly.
|
||||
|
||||
## Roadmap
|
||||
|
||||
### Phase 1 — reader + parser
|
||||
- [ ] Tokenizer: symbols (with package qualification `pkg:sym` / `pkg::sym`), numbers (int, float, ratio `1/3`, `#xFF`, `#b1010`, `#o17`), strings `"…"` with `\` escapes, characters `#\Space` `#\Newline` `#\a`, comments `;`, block comments `#| … |#`
|
||||
- [ ] Reader: list, dotted pair, quote `'`, function `#'`, quasiquote `` ` ``, unquote `,`, splice `,@`, vector `#(…)`, uninterned `#:foo`, nil/t literals
|
||||
- [ ] Parser: lambda lists with `&optional` `&rest` `&key` `&aux` `&allow-other-keys`, defaults, supplied-p variables
|
||||
- [ ] Unit tests in `lib/common-lisp/tests/read.sx`
|
||||
|
||||
### Phase 2 — sequential eval + special forms
|
||||
- [ ] `cl-eval-ast`: `quote`, `if`, `progn`, `let`, `let*`, `flet`, `labels`, `setq`, `setf` (subset), `function`, `lambda`, `the`, `locally`, `eval-when`
|
||||
- [ ] `block` + `return-from` via captured continuation
|
||||
- [ ] `tagbody` + `go` via per-tag continuations
|
||||
- [ ] `unwind-protect` cleanup frame
|
||||
- [ ] `multiple-value-bind`, `multiple-value-call`, `multiple-value-prog1`, `values`, `nth-value`
|
||||
- [ ] `defun`, `defparameter`, `defvar`, `defconstant`, `declaim`, `proclaim` (no-op)
|
||||
- [ ] Dynamic variables — `defvar`/`defparameter` produce specials; `let` rebinds via parameterize-style scope
|
||||
- [ ] 60+ tests in `lib/common-lisp/tests/eval.sx`
|
||||
|
||||
### Phase 3 — conditions + restarts (THE SHOWCASE)
|
||||
- [ ] `define-condition` — class hierarchy rooted at `condition`/`error`/`warning`/`simple-error`/`simple-warning`/`type-error`/`arithmetic-error`/`division-by-zero`
|
||||
- [ ] `signal`, `error`, `cerror`, `warn` — all walk the handler chain
|
||||
- [ ] `handler-bind` — non-unwinding handlers, may decline by returning normally
|
||||
- [ ] `handler-case` — unwinding handlers (delcc abort)
|
||||
- [ ] `restart-case`, `with-simple-restart`, `restart-bind`
|
||||
- [ ] `find-restart`, `invoke-restart`, `invoke-restart-interactively`, `compute-restarts`
|
||||
- [ ] `with-condition-restarts` — associate restarts with a specific condition
|
||||
- [ ] `*break-on-signals*`, `*debugger-hook*` (basic)
|
||||
- [ ] Classic programs in `lib/common-lisp/tests/programs/`:
|
||||
- [ ] `restart-demo.lisp` — division with `:use-zero` and `:retry` restarts
|
||||
- [ ] `parse-recover.lisp` — parser with skipped-token restart
|
||||
- [ ] `interactive-debugger.lisp` — ASCII REPL using `:debugger-hook`
|
||||
- [ ] `lib/common-lisp/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
|
||||
|
||||
### Phase 4 — CLOS
|
||||
- [ ] `defclass` with `:initarg`/`:initform`/`:accessor`/`:reader`/`:writer`/`:allocation`
|
||||
- [ ] `make-instance`, `slot-value`, `(setf slot-value)`, `with-slots`, `with-accessors`
|
||||
- [ ] `defgeneric` with `:method-combination` (standard, plus `+`, `and`, `or`)
|
||||
- [ ] `defmethod` with `:before` / `:after` / `:around` qualifiers
|
||||
- [ ] `call-next-method` (continuation), `next-method-p`
|
||||
- [ ] `class-of`, `find-class`, `slot-boundp`, `change-class` (basic)
|
||||
- [ ] Multiple dispatch — method specificity by argument-class precedence list
|
||||
- [ ] Built-in classes registered for tagged values (`integer`, `float`, `string`, `symbol`, `cons`, `null`, `t`)
|
||||
- [ ] Classic programs:
|
||||
- [ ] `geometry.lisp` — `intersect` generic dispatching on (point line), (line line), (line plane)…
|
||||
- [ ] `mop-trace.lisp` — `:before` + `:after` printing call trace
|
||||
|
||||
### Phase 5 — macros + LOOP + reader macros
|
||||
- [ ] `defmacro`, `macrolet`, `symbol-macrolet`, `macroexpand-1`, `macroexpand`
|
||||
- [ ] `gensym`, `gentemp`
|
||||
- [ ] `set-macro-character`, `set-dispatch-macro-character`, `get-macro-character`
|
||||
- [ ] **The LOOP macro** — iteration drivers (`for … in/across/from/upto/downto/by`, `while`, `until`, `repeat`), accumulators (`collect`, `append`, `nconc`, `count`, `sum`, `maximize`, `minimize`), conditional clauses (`if`/`when`/`unless`/`else`), termination (`finally`/`thereis`/`always`/`never`), `named` blocks
|
||||
- [ ] LOOP test corpus: 30+ tests covering all clause types
|
||||
|
||||
### Phase 6 — packages + stdlib drive
|
||||
- [ ] `defpackage`, `in-package`, `export`, `use-package`, `import`, `find-package`
|
||||
- [ ] Package qualification at the reader level — `cl:car`, `mypkg::internal`
|
||||
- [ ] `:common-lisp` (`:cl`) and `:common-lisp-user` (`:cl-user`) packages
|
||||
- [ ] Sequence functions — `mapcar`, `mapc`, `mapcan`, `reduce`, `find`, `find-if`, `position`, `count`, `every`, `some`, `notany`, `notevery`, `remove`, `remove-if`, `subst`
|
||||
- [ ] List ops — `assoc`, `getf`, `nth`, `last`, `butlast`, `nthcdr`, `tailp`, `ldiff`
|
||||
- [ ] String ops — `string=`, `string-upcase`, `string-downcase`, `subseq`, `concatenate`
|
||||
- [ ] FORMAT — basic directives `~A`, `~S`, `~D`, `~F`, `~%`, `~&`, `~T`, `~{...~}` (iteration), `~[...~]` (conditional), `~^` (escape), `~P` (plural)
|
||||
- [ ] Drive corpus to 200+ green
|
||||
|
||||
## Progress log
|
||||
|
||||
_Newest first._
|
||||
|
||||
- _(none yet)_
|
||||
|
||||
## Blockers
|
||||
|
||||
- _(none yet)_
|
||||
@@ -4,10 +4,10 @@ Live tally for `plans/hs-conformance-to-100.md`. Update after every cluster comm
|
||||
|
||||
```
|
||||
Baseline: 1213/1496 (81.1%)
|
||||
Merged: 1403/1496 (93.8%) delta +190
|
||||
Merged: 1277/1496 (85.4%) delta +64
|
||||
Worktree: all landed
|
||||
Target: 1496/1496 (100.0%)
|
||||
Remaining: ~89 tests
|
||||
Remaining: ~219 tests (cluster 29 blocked on sx-tree MCP outage + parser scope)
|
||||
```
|
||||
|
||||
## Cluster ledger
|
||||
@@ -22,7 +22,7 @@ Remaining: ~89 tests
|
||||
| 4 | `not` precedence over `or` | done | +3 | 4fe0b649 |
|
||||
| 5 | `some` selector for nonempty match | done | +1 | e7b86264 |
|
||||
| 6 | string template `${x}` | done | +2 | 108e25d4 |
|
||||
| 7 | `put` hyperscript reprocessing | done | +5 | 247bd85c |
|
||||
| 7 | `put` hyperscript reprocessing | partial | +1 | f21eb008 |
|
||||
| 8 | `select` returns selected text | done | +1 | d862efe8 |
|
||||
| 9 | `wait on event` basics | done | +4 | f79f96c1 |
|
||||
| 10 | `swap` variable ↔ property | done | +1 | 30f33341 |
|
||||
@@ -30,7 +30,7 @@ Remaining: ~89 tests
|
||||
| 12 | `show` multi-element + display retention | done | +2 | 98c957b3 |
|
||||
| 13 | `toggle` multi-class + timed + until-event | partial | +2 | bd821c04 |
|
||||
| 14 | `unless` modifier | done | +1 | c4da0698 |
|
||||
| 15 | `transition` query-ref + multi-prop + initial | partial | +3 | 3d352055 |
|
||||
| 15 | `transition` query-ref + multi-prop + initial | partial | +2 | 3d352055 |
|
||||
| 16 | `send can reference sender` | done | +1 | ed8d71c9 |
|
||||
| 17 | `tell` semantics | blocked | — | — |
|
||||
| 18 | `throw` respond async/sync | done | +2 | dda3becb |
|
||||
@@ -42,7 +42,7 @@ Remaining: ~89 tests
|
||||
| 19 | `pick` regex + indices | done | +13 | 4be90bf2 |
|
||||
| 20 | `repeat` property for-loops + where | done | +3 | c932ad59 |
|
||||
| 21 | `possessiveExpression` property access via its | done | +1 | f0c41278 |
|
||||
| 22 | window global fn fallback | done | +1 | d31565d5 |
|
||||
| 22 | window global fn fallback | blocked | — | — |
|
||||
| 23 | `me symbol works in from expressions` | done | +1 | 0d38a75b |
|
||||
| 24 | `properly interpolates values 2` | done | +1 | cb37259d |
|
||||
| 25 | parenthesized commands and features | done | +1 | d7a88d85 |
|
||||
@@ -54,52 +54,42 @@ Remaining: ~89 tests
|
||||
| 26 | resize observer mock + `on resize` | done | +3 | 304a52d2 |
|
||||
| 27 | intersection observer mock + `on intersection` | done | +3 | 0c31dd27 |
|
||||
| 28 | `ask`/`answer` + prompt/confirm mock | done | +4 | 6c1da921 |
|
||||
| 29 | `hyperscript:before:init` / `:after:init` / `:parse-error` | partial | +2 | e01a3baa |
|
||||
| 29 | `hyperscript:before:init` / `:after:init` / `:parse-error` | blocked | — | — |
|
||||
| 30 | `logAll` config | done | +1 | 64bcefff |
|
||||
|
||||
### Bucket D — medium features
|
||||
|
||||
| # | Cluster | Status | Δ |
|
||||
|---|---------|--------|---|
|
||||
| 31 | runtime null-safety error reporting | done | +13 |
|
||||
| 32 | MutationObserver mock + `on mutation` | done | +7 |
|
||||
| 33 | cookie API | partial | +4 |
|
||||
| 34 | event modifier DSL | partial | +7 |
|
||||
| 35 | namespaced `def` | done | +3 |
|
||||
| 36b | `call` result binds to `it` | done | +1 | 35f498ec |
|
||||
| 31 | runtime null-safety error reporting | pending | (+15–18 est) |
|
||||
| 32 | MutationObserver mock + `on mutation` | pending | (+10–15 est) |
|
||||
| 33 | cookie API | pending | (+5 est) |
|
||||
| 34 | event modifier DSL | pending | (+6–8 est) |
|
||||
| 35 | namespaced `def` | pending | (+3 est) |
|
||||
|
||||
### Bucket E — subsystems (design docs landed, pending review + implementation)
|
||||
|
||||
| # | Cluster | Status | Design doc |
|
||||
|---|---------|--------|------------|
|
||||
| 36 | WebSocket + `socket` + RPC proxy | done | +16 | (pending) |
|
||||
| 37 | Tokenizer-as-API | done | +17 | 54b54f4e |
|
||||
| 36 | WebSocket + `socket` + RPC proxy | design-done | `plans/designs/e36-websocket.md` |
|
||||
| 37 | Tokenizer-as-API | design-done | `plans/designs/e37-tokenizer-api.md` |
|
||||
| 38 | SourceInfo API | design-done | `plans/designs/e38-sourceinfo.md` |
|
||||
| 39 | WebWorker plugin | design-done | `plans/designs/e39-webworker.md` |
|
||||
| 40 | Fetch non-2xx / before-fetch / real response | done | +7 | d7244d1d |
|
||||
| 40 | Fetch non-2xx / before-fetch / real response | design-done | `plans/designs/e40-real-fetch.md` |
|
||||
|
||||
### Bucket F — generator translation gaps
|
||||
|
||||
Defer until A–D drain. Estimated ~25 recoverable tests.
|
||||
|
||||
| # | Cluster | Status | Δ | Commit |
|
||||
|---|---------|--------|---|--------|
|
||||
| F1 | add CSS template interpolation | done | +1 | 5a76a040 |
|
||||
| F2 | empty multi-element (query→for-each) | done | +1 | 875e9ba3 |
|
||||
| F3 | hs-make-object _order + assert= for dicts | done | +1 | daea2808 |
|
||||
| F4 | array literal arg to JS fn (sxToJs + reduce→SX) | done | +1 | da2e6b1b |
|
||||
| F5 | `bind` feature parser stub | done | +32 | 846650da |
|
||||
| F6 | `asyncError` rejected promise catch | done | +1 | — |
|
||||
|
||||
## Buckets roll-up
|
||||
|
||||
| Bucket | Done | Partial | In-prog | Pending | Blocked | Design-done | Total |
|
||||
|--------|-----:|--------:|--------:|--------:|--------:|------------:|------:|
|
||||
| A | 12 | 4 | 0 | 0 | 1 | — | 17 |
|
||||
| B | 7 | 0 | 0 | 0 | 0 | — | 7 |
|
||||
| C | 4 | 1 | 0 | 0 | 0 | — | 5 |
|
||||
| D | 2 | 2 | 0 | 0 | 1 | — | 5 |
|
||||
| E | 3 | 0 | 0 | 0 | 0 | 2 | 5 |
|
||||
| B | 6 | 0 | 0 | 0 | 1 | — | 7 |
|
||||
| C | 4 | 0 | 0 | 0 | 1 | — | 5 |
|
||||
| D | 0 | 0 | 0 | 5 | 0 | — | 5 |
|
||||
| E | 0 | 0 | 0 | 0 | 0 | 5 | 5 |
|
||||
| F | — | — | — | ~10 | — | — | ~10 |
|
||||
|
||||
## Maintenance
|
||||
|
||||
@@ -61,7 +61,7 @@ Orchestrator cherry-picks worktree commits onto `architecture` one at a time; re
|
||||
|
||||
6. **[done (+2)] string template `${x}`** — `expressions/strings / string templates work w/ props` + `w/ braces` (2 tests). Template interpolation isn't substituting property accesses. Check `hs-template` runtime. Expected: +2.
|
||||
|
||||
7. **[done (+5)] `put` hyperscript reprocessing** — `put / properly processes hyperscript at end/start/content/symbol` (4 tests, all `Expected 42, got 40`). After a put operation, newly inserted HS scripts aren't being activated. Fix: `hs-put-at!` should `hs-boot-subtree!` on the target after DOM insertion. Expected: +4.
|
||||
7. **[done (+1) — partial, 3 tests remain: inserted-button handler doesn't fire for afterbegin/innerHTML paths; might need targeted trace of hs-boot-subtree! or _setInnerHTML timing] `put` hyperscript reprocessing** — `put / properly processes hyperscript at end/start/content/symbol` (4 tests, all `Expected 42, got 40`). After a put operation, newly inserted HS scripts aren't being activated. Fix: `hs-put-at!` should `hs-boot-subtree!` on the target after DOM insertion. Expected: +4.
|
||||
|
||||
8. **[done (+1)] `select returns selected text`** (1 test, `hs-upstream-select`). Runtime `hs-get-selection` helper reads `window.__test_selection` stash (or falls back to real `window.getSelection().toString()`). Compiler rewrites `(ref "selection")` to `(hs-get-selection)`. Generator detects the `createRange` / `setStart` / `setEnd` / `addRange` block and emits a single `(host-set! ... __test_selection ...)` op with the resolved text slice of the target element. Expected: +1.
|
||||
|
||||
@@ -69,7 +69,7 @@ Orchestrator cherry-picks worktree commits onto `architecture` one at a time; re
|
||||
|
||||
10. **[done (+1)] `swap` variable ↔ property** — `swap / can swap a variable with a property` (1 test). Swap command doesn't handle mixed var/prop targets. Expected: +1.
|
||||
|
||||
11. **[done (+4)] `hide` strategy** — `hide / can configure hidden as default`, `can hide with custom strategy`, `can set default to custom strategy`, `hide element then show element retains original display` (4 tests). Strategy config plumbing. Expected: +3-4.
|
||||
11. **[done (+3) — partial, `hide element then show element retains original display` remains; needs `on click N` count-filtered event handlers, out of scope for this cluster] `hide` strategy** — `hide / can configure hidden as default`, `can hide with custom strategy`, `can set default to custom strategy`, `hide element then show element retains original display` (4 tests). Strategy config plumbing. Expected: +3-4.
|
||||
|
||||
12. **[done (+2)] `show` multi-element + display retention** — `show / can show multiple elements with inline-block`, `can filter over a set of elements using the its symbol` (2 tests). Expected: +2.
|
||||
|
||||
@@ -93,7 +93,7 @@ Orchestrator cherry-picks worktree commits onto `architecture` one at a time; re
|
||||
|
||||
21. **[done (+1)] `possessiveExpression` property access via its** — `possessive / can access its properties` (1 test, Expected `foo` got ``). Expected: +1.
|
||||
|
||||
22. **[done (+1)] window global fn fallback** — `regressions / can invoke functions w/ numbers in name` + `can refer to function in init blocks`. Added `host-call-fn` FFI primitive (commit 337c8265), `hs-win-call` runtime helper, simplified compiler emit (direct hs-win-call, no guard), `def` now also registers fn on `window[name]`. Generator: fixed `\"` escaping in hs-compile string literals. Expected: +2-4.
|
||||
22. **[blocked: tried three compile-time emits — (1) guard (can't catch Undefined symbol since it's a host-level error, not an SX raise), (2) env-has? (primitive not loaded in HS kernel — `Unhandled exception: "env-has?"`), and (3) hs-win-call runtime helper (works when reached but SX can't CALL a host-handle function directly — `Not callable: {:__host_handle N}` because NativeFn is not callable here). Needs either a host-call-fn primitive with arity-agnostic dispatch OR a symbol-bound? predicate in the HS kernel.] window global fn fallback** — `regressions / can invoke functions w/ numbers in name` + unlocks several others. When calling `foo()` where `foo` isn't SX-defined, fall back to `(host-global "foo")`. Design decision: either compile-time emit `(or foo (host-global "foo"))` via a helper, or add runtime lookup in the dispatch path. Expected: +2-4.
|
||||
|
||||
23. **[done (+1)] `me symbol works in from expressions`** — `regressions` (1 test, Expected `Foo`). Check `from` expression compilation. Expected: +1.
|
||||
|
||||
@@ -109,23 +109,21 @@ Orchestrator cherry-picks worktree commits onto `architecture` one at a time; re
|
||||
|
||||
28. **[done (+4)] `ask`/`answer` + prompt/confirm mock** — `askAnswer` 4 tests. **Requires test-name-keyed mock**: first test wants `confirm → true`, second `confirm → false`, third `prompt → "Alice"`, fourth `prompt → null`. Keyed via `_current-test-name` in the runner. Expected: +4.
|
||||
|
||||
29. **[done (+2) — partial, 4 parser-error tests remain (basic parse error messages, parse-error event, EOF newline crash, evaluate-api-first-error). All require stricter parser error-rejection — `add - to` currently parses silently to `(set! nil (hs-add-to! (- 0 nil) nil))`, `on click blargh end on mouseenter also_bad` parses silently to `(do (hs-on me "click" (fn (event) blargh)) (hs-on me "mouseenter" (fn (event) also_bad)))`. Plus emit-error-collection runtime + hyperscript:parse-error event with detail.errors. Larger than a single cluster budget; recommend bucket-D plan-first.] `hyperscript:before:init` / `:after:init` / `:parse-error` events** — 6 tests in `bootstrap` + `parser`. Fire DOM events at activation boundaries. Expected: +4-6.
|
||||
29. **[blocked: sx-tree MCP tools returning Yojson Type_error on every file op. Can't edit integration.sx to add before:init/after:init dispatch. Also 4 of the 6 tests fundamentally require stricter parser error-rejection (add - to currently succeeds as SX expression; on click blargh end accepts blargh as symbol), which is larger than a single cluster budget.] `hyperscript:before:init` / `:after:init` / `:parse-error` events** — 6 tests in `bootstrap` + `parser`. Fire DOM events at activation boundaries. Expected: +4-6.
|
||||
|
||||
30. **[done (+1)] `logAll` config** — 1 test. Global config that console.log's each command. Expected: +1.
|
||||
|
||||
### Bucket D: medium features (bigger commits, plan-first)
|
||||
|
||||
31. **[blocked: Bucket-D plan-first scope, doesn't fit one cluster budget. All 18 tests are SKIP (untranslated) — generator has no `error("HS")` helper. Required pieces: (a) generator-side `eval-hs-error` helper + recognizer for `expect(await error("HS")).toBe("MSG")` blocks; (b) runtime helpers `hs-null-error!` / `hs-named-target` / `hs-named-target-list` raising `'<sel>' is null`; (c) compiler patches at every target-position `(query SEL)` emit to wrap in named-target carrying the original selector source — that's ~17 command emit paths (add, remove, hide, show, measure, settle, trigger, send, set, default, increment, decrement, put, toggle, transition, append, take); (d) function-call null-check at bare `(name)`, `hs-method-call`, and `host-get` chains, deriving the leftmost-uncalled-name `'x'` / `'x.y'` from the parse tree; (e) possessive-base null-check (`set x's y to true` → `'x' is null`). Each piece is straightforward in isolation but the cross-cutting compiler change touches every emit path and needs a coordinated design pass. Recommend a dedicated design doc + multi-commit worktree like buckets E36-E40.] runtime null-safety error reporting** — 18 tests in `runtimeErrors`. When accessing `.foo` on nil, emit a structured error with position info. One coordinated fix in the compiler emit paths for property access, function calls, set/put. Expected: +15-18.
|
||||
31. **[pending] runtime null-safety error reporting** — 18 tests in `runtimeErrors`. When accessing `.foo` on nil, emit a structured error with position info. One coordinated fix in the compiler emit paths for property access, function calls, set/put. Expected: +15-18.
|
||||
|
||||
32. **[done (+7)] MutationObserver mock + `on mutation` dispatch** — 7 tests in `on`. Add MO mock to runner. Compile `on mutation [of attribute/childList/attribute-specific]`. Expected: +10-15.
|
||||
32. **[pending] MutationObserver mock + `on mutation` dispatch** — 15 tests in `on`. Add MO mock to runner. Compile `on mutation [of attribute/childList/attribute-specific]`. Expected: +10-15.
|
||||
|
||||
33. **[done (+4) — partial, 1 test remains: `iterate cookies values work` needs `hs-for-each` to recognise host-array/proxy collections (currently `(list? collection)` returns false for the JS Proxy so the loop body never runs). Out of scope.] cookie API** — 5 tests in `expressions/cookies`. `document.cookie` mock in runner + `the cookies` + `set the xxx cookie` keywords. Expected: +5.
|
||||
33. **[pending] cookie API** — 5 tests in `expressions/cookies`. `document.cookie` mock in runner + `the cookies` + `set the xxx cookie` keywords. Expected: +5.
|
||||
|
||||
34. **[done (+7) — partial, 1 test remains: `every` keyword multi-handler-execute test needs handler-queue semantics where `wait for X` doesn't block subsequent invocations of the same handler — current `hs-on-every` shares the same dom-listen plumbing as `hs-on` and queues events implicitly via JS event loop, so the third synthetic click waits for the prior handler's `wait for customEvent` to settle. Out of single-cluster scope.] event modifier DSL** — 8 tests in `on`. `elsewhere`, `every`, `first click`, count filters (`once / twice / 3 times`, ranges), `from elsewhere`. Expected: +6-8.
|
||||
34. **[pending] event modifier DSL** — 8 tests in `on`. `elsewhere`, `every`, `first click`, count filters (`once / twice / 3 times`, ranges), `from elsewhere`. Expected: +6-8.
|
||||
|
||||
35. **[done (+3)] namespaced `def`** — 3 tests. `def ns.foo() ...` creates `ns.foo`. Expected: +3.
|
||||
|
||||
36b. **[done (+1)] `call` result binds to `it`** — `call / call functions that return promises are waited on` (1 test). `call X then put it into Y` wasn't setting `it` because the `call` compiler branch emitted the call expression directly without `emit-set`. Fixed by wrapping in `emit-set (quote the-result) call-expr`. Expected: +1.
|
||||
35. **[pending] namespaced `def`** — 3 tests. `def ns.foo() ...` creates `ns.foo`. Expected: +3.
|
||||
|
||||
### Bucket E: subsystems (DO NOT LOOP — human-driven)
|
||||
|
||||
@@ -133,13 +131,13 @@ All five have design docs on their own worktree branches pending review + merge.
|
||||
|
||||
36. **[design-done, pending review — `plans/designs/e36-websocket.md` on `worktree-agent-a9daf73703f520257`] WebSocket + `socket`** — 16 tests. Upstream shape is `socket NAME URL [with timeout N] [on message [as JSON] …] end` with an **implicit `.rpc` Proxy** (ES6 Proxy lives in JS, not SX), not `with proxy { send, receive }` as this row previously claimed. Design doc has 8-commit checklist, +12–16 delta estimate. Ship only with intentional design review.
|
||||
|
||||
37. **[done +17]** Tokenizer-as-API — `hs-tokens-of` / `hs-stream-token` / `hs-token-type` / `hs-token-value` / `hs-token-op?`; type-map + normalize; `read-number` dot-stop fix; `\$` template escape in compiler + runtime; generator pattern in `generate-sx-tests.py`. 17/17.
|
||||
37. **[design-done, pending review — `plans/designs/e37-tokenizer-api.md` on `worktree-agent-a6bb61d59cc0be8b4`] Tokenizer-as-API** — 17 tests. Expose tokens as inspectable SX data via `hs-tokens-of` / `hs-stream-token` / `hs-token-type` etc; type-map current `hs-tokenize` output to upstream SCREAMING_SNAKE_CASE. 8-step checklist, +16–17 delta.
|
||||
|
||||
38. **[design-done, pending review — `plans/designs/e38-sourceinfo.md` on `agent-e38-sourceinfo`] SourceInfo API** — 4 tests. Inline span-wrapper strategy (not side-channel dict) with compiler-entry unwrap. 4-commit plan.
|
||||
|
||||
39. **[design-done, pending review — `plans/designs/e39-webworker.md` on `hs-design-e39-webworker`] WebWorker plugin** — 1 test. Parser-only stub that errors with a link to upstream docs; no runtime, no mock Worker class. Hand-write the test (don't patch the generator). Single commit.
|
||||
|
||||
40. **[done +7 — d7244d1d] Fetch non-2xx / before-fetch event / real response object** — 7 tests. SX-dict Response wrapper `{:_hs-response :ok :status :url :_body :_json :_html}`; restructured `hs-fetch` that always fetches wrapper then converts by format; test-name-keyed `_fetchScripts`. 11-step checklist. Watch for regression on cluster-1 JSON unwrap.
|
||||
40. **[design-done, pending review — `plans/designs/e40-real-fetch.md` on `worktree-agent-a94612a4283eaa5e0`] Fetch non-2xx / before-fetch event / real response object** — 7 tests. SX-dict Response wrapper `{:_hs-response :ok :status :url :_body :_json :_html}`; restructured `hs-fetch` that always fetches wrapper then converts by format; test-name-keyed `_fetchScripts`. 11-step checklist. Watch for regression on cluster-1 JSON unwrap.
|
||||
|
||||
### Bucket F: generator translation gaps (after bucket A-D)
|
||||
|
||||
@@ -177,62 +175,8 @@ Many tests are `SKIP (untranslated)` because `tests/playwright/generate-sx-tests
|
||||
|
||||
## Progress log
|
||||
|
||||
### 2026-04-26 — Bucket F: array literal arg to JS fn (+1)
|
||||
- **da2e6b1b** — `HS Bucket F: array literal arg to JS fn fix (+1 test)`. Two-part fix: (a) `generate-sx-tests.py` `js_expr_to_sx` now translates `arr.reduce(fn, init)` → `(reduce fn init arr)`, `.map(fn)` → `(map fn arr)`, `.filter(fn)` → `(filter fn arr)` so SX list arguments work with JS array HO methods. (b) `host-call-fn` in `hs-run-filtered.js` adds `sxToJs` recursive converter that unwraps SX list `._type==='list'` to native JS arrays before calling native JS functions. Together these fix functionCalls "can pass an array literal as an argument". Suite hs-upstream-expressions/functionCalls: 8/12 (unchanged SKIP ratio). Test 597: 0/1 → 1/1. Smoke 0-195: 175/195 unchanged.
|
||||
|
||||
### 2026-04-26 — Bucket F: hs-make-object _order + assert= for dicts (+1)
|
||||
- **daea2808** — `HS Bucket F: fix hs-make-object _order + assert= for dicts (+1 test)`. Two-part fix: (a) `runtime.sx` `hs-make-object` no longer appends `_order` key to HS object literals — V8's native string-key insertion order is sufficient, and the hidden key was breaking structural equality. (b) `generate-sx-tests.py` `emit_eval` now detects when `expected_sx` contains `{` (dict syntax) and emits `assert-equal` (which uses `equal?` for deep structural equality) instead of `assert=` (which uses `=`, reference equality for dicts). Together these fix arrayLiteral "arrays containing objects work". Suite hs-upstream-expressions/arrayLiteral: 7/8 → 8/8. Smoke 0-195 unchanged at 175/195.
|
||||
|
||||
### 2026-04-26 — Bucket F: empty multi-element fix (+1)
|
||||
- **875e9ba3** — `HS: empty multi-element fix (+1 test)`. `empty .class` compiled `(empty-target (query ".class"))` through `hs-to-sx` → `(hs-empty-target! (hs-query-first ".class"))` which only emptied the first match. Fix: detect `(query ...)` target in the `empty-target` compiler case and emit `(for-each (fn (_el) (hs-empty-target! _el)) (hs-query-all sel))`, mirroring the `add-class` pattern. Suite hs-upstream-empty: 12/13 → 13/13. Smoke 0-195: 175/195 unchanged.
|
||||
|
||||
### 2026-04-26 — Bucket F: add CSS template interpolation (+1)
|
||||
- **5a76a040** — `HS: add CSS template interpolation fix (+1 test)`. `add {color: ${}{"red"}}` uses two consecutive brace groups: the empty `${}` marker followed by `{"red"}` for the actual value. The prior parser fix called `parse-expr` when already at the closing `}` of the empty group, returning nil. Fix: detect the empty-brace case (`brace-open` → immediately `brace-close`), skip it, then read the actual value from the next `{…}` block. Also handles normal `${expr}` correctly. Suite hs-upstream-add: 17/19 → 18/19. Smoke 0-195: 174/195 → 175/195.
|
||||
|
||||
### 2026-04-26 — cluster 36b call result binds to it (done +1)
|
||||
- **35f498ec** — `hs: call command binds result to it via emit-set (+1 test)`. `call X then put it into Y` compiled `call X` without `emit-set`, so `it` remained nil. Wrapped call-expr in `emit-set (quote the-result) ...` so both `it` and `the-result` are updated. Suite hs-upstream-call: 5/6 → 6/6. Smoke 0-195: 173/195 → 174/195.
|
||||
|
||||
### 2026-04-26 — cluster 7 put hyperscript reprocessing (done, final +1)
|
||||
- **247bd85c** — `hs: register promiseAString/promiseAnInt as sync test fixtures (+1 test)`. Upstream test "waits on promises" calls `promiseAString()` via window global. OCaml run_tests.ml registers these as NativeFns returning "foo"/"42" synchronously; JS runner had no equivalent. Added `globalThis.promiseAString = () => 'foo'` and `globalThis.promiseAnInt = () => 42` to hs-run-filtered.js. Suite hs-upstream-put: 37/38 → 38/38 (fully done). Smoke 0-195: 173/195 unchanged.
|
||||
|
||||
### 2026-04-26 — cluster 7 put hyperscript reprocessing (partial +3 more)
|
||||
- **d663c91f** — `hs: stop event propagation after each hs-on handler fires (+3 tests)`. Root cause: click events bubble from b1 (inside d1) to d1, causing d1's `on click put ...` handler to re-fire and replace the just-modified b1 with fresh content (text=40). Fix: `hs-on`'s wrapped handler now calls `event.stopPropagation()` after each handler runs, preventing the bubbled click from reaching ancestor HS listeners. Tests 1147/1149/1150 now pass. Suite hs-upstream-put: 34/38 → 37/38. Smoke 0-195: 173/195 unchanged. One test remains: "waits on promises" (async/Promise issue).
|
||||
|
||||
(Reverse chronological — newest at top.)
|
||||
|
||||
### 2026-04-25 — Bucket F: in-expression filter semantics (+1)
|
||||
- **67a5f137** — `HS: in-expression filter semantics (+1 test)`. `1 in [1, 2, 3]` was returning boolean `true` instead of the filtered list `(list 1)`. Root cause: `in?` compiled to `hs-contains?` which returns boolean for scalar items. Fix: (a) `runtime.sx` adds `hs-in?` returning filtered list for all cases, plus `hs-in-bool?` which wraps with `(not (hs-falsy? ...))` for boolean contexts; (b) `compiler.sx` changes `in?` clause to emit `(hs-in? collection item)` and adds new `in-bool?` clause emitting `(hs-in-bool? collection item)`; (c) `parser.sx` changes `is in` and `am in` comparison forms to produce `in-bool?` so those stay boolean. Suite hs-upstream-expressions/in: 8/9 → 9/9. Smoke 0-195: 173/195 unchanged.
|
||||
|
||||
### 2026-04-25 — cluster 22 window global fn fallback (+1)
|
||||
- **d31565d5** — `HS cluster 22: simplify win-call emit + def→window + init-blocks test (+1)`. Two-part change building on 337c8265 (host-call-fn FFI + hs-win-call runtime). (a) `compiler.sx` removes the guard wrapper from bare-call and method-call `hs-win-call` emit paths — direct `(hs-win-call name (list args))` is sufficient since hs-win-call returns nil for unknown names; `def` compilation now also emits `(host-set! (host-global "window") name fn)` so every HS-defined function is reachable via window lookup. (b) `generate-sx-tests.py` fixes a quoting bug: `\"here\"` was being embedded as three SX nodes (`""` + symbol + `""`) instead of a single escaped-quote string; fixed with `\\\"` escaping. Hand-rolled deftest for `can refer to function in init blocks` now passes. Suite hs-upstream-core/regressions: 13/16 → 14/16. Smoke 0-195: 172/195 → 173/195.
|
||||
|
||||
### 2026-04-25 — cluster 11/33 followups: hide strategy + cookie clear (+2)
|
||||
- **5ff2b706** — `HS: cluster 11/33 followups (+2 tests)`. Three orthogonal fixes that pick up tests now unblocked by earlier work. (a) `parser.sx` `parse-hide-cmd`/`parse-show-cmd`: added `on` to the keyword set that flips the implicit-`me` target. Previously `on click 1 hide on click 2 show` silently parsed as `(hs-hide! nil ...)` because `parse-expr` started consuming `on` and returned nil; now hide/show recognise a sibling feature and default to `me`. (b) `runtime.sx` `hs-method-call` fallback for non-built-in methods: SX-callables (lambdas) call via `apply`, JS-native functions (e.g. `cookies.clear`) dispatch via `(apply host-call (cons obj (cons method args)))` so the native receives the args list. (c) Generator `hs-cleanup!` body wrapped in `begin` (fn body evaluates only the last expr) and now resets `hs-set-default-hide-strategy! nil` + `hs-set-log-all! false` between tests — the prior `can set default to custom strategy` cluster-11 test had been leaking `_hs-default-hide-strategy` into the rest of the suite, breaking `hide element then show element retains original display`. New cluster-33 hand-roll for `basic clear cookie values work` exercises the method-call fallback. Suite hs-upstream-hide: 15/16 → 16/16. Suite hs-upstream-expressions/cookies: 3/5 → 4/5. Smoke 0-195 unchanged at 172/195.
|
||||
|
||||
### 2026-04-25 — cluster 35 namespaced def + script-tag globals (+3)
|
||||
- **122053ed** — `HS: namespaced def + script-tag global functions (+3 tests)`. Two-part change: (a) `runtime.sx` `hs-method-call` gains a fallback for unknown methods — `(let ((fn-val (host-get obj method))) (if (callable? fn-val) (apply fn-val args) nil))`. This lets `utils.foo()` dispatch through `(host-get utils "foo")` when `utils` is an SX dict whose `foo` is an SX lambda. (b) Generator hand-rolls 3 deftests since the SX runtime has no `<script type='text/hyperscript'>` tag boot. For `is called synchronously` / `can call asynchronously`: `(eval-expr-cek (hs-to-sx (first (hs-parse (hs-tokenize "def foo() ... end")))))` registers the function in the global eval env (eval-expr-cek processes `(define foo (fn ...))` at top scope), then a click div is built via dom-set-attr + hs-boot-subtree!. For `functions can be namespaced`: define `utils` as a dict, register `__utils_foo` as a fresh-named global def, then `(host-set! utils "foo" __utils_foo)` populates the dict; click handler `call utils.foo()` compiles to `(hs-method-call utils "foo")` which now dispatches through the new runtime fallback. Skip-list cleared of the 3 def entries. Suite hs-upstream-def: 24/27 → 27/27. Smoke 0-195 unchanged at 172/195.
|
||||
|
||||
### 2026-04-25 — cluster 34 elsewhere / from-elsewhere modifier (+2)
|
||||
- **3044a168** — `HS: elsewhere / from elsewhere modifier (+2 tests)`. Three-part change: (a) `parser.sx` `parse-on-feat` parses an optional `elsewhere` (or `from elsewhere`) modifier between event-name and source. The `from elsewhere` variant uses a one-token lookahead so plain `from #target` keeps parsing as a source expression. Emits `:elsewhere true` part. (b) `compiler.sx` `scan-on` threads `elsewhere?` (10th param) through every recursive call + new `:elsewhere` cond branch. The dispatch case becomes a 3-way `cond` over target: elsewhere → `(dom-body)` (listener attaches to body and bubble sees every click), source → from-source, default → `me`. The `compiled-body` build is wrapped with `(when (not (host-call me "contains" (host-get event "target"))) BODY)` so handlers fire only on outside-of-`me` clicks. (c) Generator drops `supports "elsewhere" modifier` and `supports "from elsewhere" modifier` from `SKIP_TEST_NAMES`. Suite hs-upstream-on: 48/70 → 50/70. Smoke 0-195 unchanged at 172/195.
|
||||
|
||||
### 2026-04-25 — cluster 34 count-filtered events + first modifier (+5 partial)
|
||||
- **19c97989** — `HS: count-filtered events + first modifier (+5 tests)`. Three-part change: (a) `parser.sx` `parse-on-feat` accepts `first` keyword before event-name (sets `cnt-min/max=1`), then optionally parses a count expression after event-name: bare number = exact count, `N to M` = inclusive range, `N and on` = unbounded above. Number tokens coerced via `parse-number`. New parts entry `:count-filter {"min" N "max" M-or--1}`. (b) `compiler.sx` `scan-on` gains a 9th `count-filter-info` param threaded through every recursive call + a new `:count-filter` cond branch. The handler binding now wraps the `(fn (event) BODY)` in `(let ((__hs-count 0)) (fn (event) (begin (set! __hs-count (+ __hs-count 1)) (when COUNT-CHECK BODY))))` when count info is present. Each `on EVENT N ...` clause produces its own closure-captured counter, so `on click 1` / `on click 2` / `on click 3` fire on their respective Nth click (mix-ranges test). (c) Generator drops 5 entries from `SKIP_TEST_NAMES` — `can filter events based on count`/`...count range`/`...unbounded count range`/`can mix ranges`/`on first click fires only once`. Suite hs-upstream-on: 43/70 → 48/70. Smoke 0-195 unchanged at 172/195. Remaining cluster-34 work (`elsewhere`/`from elsewhere`/`every`-keyword multi-handler) is independent from count filters and would need a separate iteration.
|
||||
|
||||
### 2026-04-25 — cluster 29 hyperscript init events (+2 partial)
|
||||
- **e01a3baa** — `HS: hyperscript:before:init / :after:init events (+2 tests)`. `integration.sx` `hs-activate!` now wraps the activation block in `(when (dom-dispatch el "hyperscript:before:init" nil) ...)` — `dom-dispatch` builds a CustomEvent with `bubbles:true`, the mock El's `cancelable` defaults to true, `dispatchEvent` returns `!ev.defaultPrevented`, so `when` skips the activate body if a listener called `preventDefault()`. After activation completes successfully it dispatches `hyperscript:after:init`. Generator (`tests/playwright/generate-sx-tests.py`) gains two hand-rolled deftests: `fires hyperscript:before:init and hyperscript:after:init` builds a wa container, attaches listeners that append to a captured `events` list, sets innerHTML to a div with `_=`, calls `hs-boot-subtree!`, asserts the events list. `hyperscript:before:init can cancel initialization` attaches a preventDefault listener and asserts `data-hyperscript-powered` is absent on the inner div after boot. Suite hs-upstream-core/bootstrap: 20/26 → 22/26. Smoke 0-195: 170 → 172. Remaining 4 cluster-29 tests (basic parse error messages, parse-error event, EOF newline, eval-API throws on first error) all need stricter parser error-rejection plus a parse-error collector — recommend bucket-D plan-first multi-commit, not a single iteration.
|
||||
|
||||
### 2026-04-25 — cluster 32 MutationObserver mock + on mutation dispatch (+7)
|
||||
- **13e02542** — `HS: MutationObserver mock + on mutation dispatch (+7 tests)`. Five-part change: (a) `parser.sx` `parse-on-feat` now consumes `of <FILTER>` after `mutation` event-name. FILTER is one of `attributes`/`childList`/`characterData` (ident tokens) or one or more `@name` attr-tokens chained by `or`. Emits `:of-filter {"type" T "attrs" L?}` part. (b) `compiler.sx` `scan-on` threads new `of-filter-info` param; the dispatch case becomes a `cond` over `event-name` — for `"mutation"` it emits `(do on-call (hs-on-mutation-attach! target MODE ATTRS))` where ATTRS is `(cons 'list attr-list)` so the list survives compile→eval. (c) `runtime.sx` `hs-on-mutation-attach!` builds a config dict (`attributes`/`childList`/`characterData`/`subtree`/`attributeFilter`) matched to mode, constructs a real `MutationObserver(cb)`, calls `mo.observe(target, opts)`, and the cb dispatches a `"mutation"` event on target. (d) `tests/hs-run-filtered.js` replaces the no-op MO with `HsMutationObserver` (global registry, decodes SX-list `attributeFilter`); prototype hooks on `El.setAttribute/appendChild/removeChild/_setInnerHTML` fire matching observers synchronously, with `__hsMutationActive` re-entry guard so handlers that mutate the DOM don't infinite-loop. Per-test reset clears registry + flag. (e) `generate-sx-tests.py` drops 7 mutation entries from `SKIP_TEST_NAMES` and adds two body patterns: `evaluate(() => document.querySelector(SEL).setAttribute(N,V))` → `(dom-set-attr ...)`, and `evaluate(() => document.querySelector(SEL).appendChild(document.createElement(T)))` → `(dom-append … (dom-create-element …))`. Suite hs-upstream-on: 36/70 → 43/70. Smoke 0-195 unchanged at 170/195.
|
||||
|
||||
### 2026-04-25 — cluster 33 cookie API (partial +3)
|
||||
- No `.sx` edits needed — `set cookies.foo to 'bar'` already compiles to `(dom-set-prop cookies "foo" "bar")` which becomes `(host-set! cookies "foo" "bar")` once the `dom` module is loaded, and `cookies.foo` becomes `(host-get cookies "foo")`. So a JS-only Proxy + Python generator change does the trick. Two parts: (a) `tests/hs-run-filtered.js` adds a per-test `__hsCookieStore` Map, a `globalThis.cookies` Proxy with `length`/`clear`/named-key get traps and a set trap that writes the store, and a `Object.defineProperty(document, 'cookie', …)` getter/setter that reads and writes the same store (so the upstream `length is 0` test's pre-clear loop over `document.cookie` works). Per-test reset clears the store. (b) `tests/playwright/generate-sx-tests.py` declares `(define cookies (host-global "cookies"))` in the test header and emits hand-rolled deftests for the three tractable tests (`basic set`, `update`, `length is 0`). Suite hs-upstream-expressions/cookies: 0/5 → 3/5. Smoke 0-195 unchanged at 170/195. Remaining `basic clear` and `iterate` tests need runtime.sx edits (hs-method-call fallback + hs-for-each host-array recognition) — out of scope for a JS-only iteration.
|
||||
|
||||
### 2026-04-25 — cluster 32 MutationObserver mock + on mutation dispatch (blocked)
|
||||
- Two issues conspire: (1) `loops/hs` worktree has no pre-built sx-tree binary so MCP tools aren't loaded, and the block-sx-edit hook prevents raw `Edit`/`Read`/`Write` on `.sx` files. Built `hosts/ocaml/_build/default/bin/mcp_tree.exe` via `dune build` this iteration but tools don't surface mid-session. (2) Cluster scope is genuinely big: parser must learn `on mutation of <filter>` (currently drops body after `of` — verified via compile dump: `on mutation of attributes put "Mutated" into me` → `(hs-on me "mutation" (fn (event) nil))`), compiler needs `:of-filter` plumbing similar to intersection's `:having`, runtime needs `hs-on-mutation-attach!`, JS runner mock needs a real MutationObserver (currently no-op `class{observe(){}disconnect(){}}` at hs-run-filtered.js:348) plus `setAttribute`/`appendChild` instrumentation, and 7 entries removed from `SKIP_TEST_NAMES`. Recommended next step: dedicated worktree where sx-tree loads at session start, multi-commit shape (parser → compiler+attach → mock+runner → generator skip-list).
|
||||
|
||||
### 2026-04-25 — cluster 31 runtime null-safety error reporting (blocked)
|
||||
- All 18 tests are `SKIP (untranslated)` — generator has no `error("HS")` helper at all. Inspected representative compile outputs: `add .foo to #doesntExist` → `(for-each ... (hs-query-all "#doesntExist"))` (silently no-ops on empty list, no error); `hide #doesntExist` → `(hs-hide! (hs-query-all "#doesntExist") "display")` (likewise); `put 'foo' into #doesntExist` → `(hs-set-inner-html! (hs-query-first "#doesntExist") "foo")` (passes nil through); `x()` → `(x)` (raises `Undefined symbol: x`, wrong format); `x.y.z()` → `(hs-method-call (host-get x "y") "z")`. Implementing this requires generator helper + 17 compiler emit-path patches + function-call/method-call/possessive-base null guards + new `hs-named-target`/`hs-named-target-list` runtime — too many surfaces for a single-iteration commit. Bucket D explicitly says "plan-first" — recommended path is a dedicated design doc and multi-commit worktree like E36-E40, not a loop iteration.
|
||||
|
||||
### 2026-04-24 — cluster 29 hyperscript:before:init / :after:init / :parse-error (blocked)
|
||||
- **2b486976** — `HS-plan: mark cluster 29 blocked`. sx-tree MCP file ops returning `Yojson__Safe.Util.Type_error("Expected string, got null")` on every file-based call (sx_read_subtree, sx_find_all, sx_replace_by_pattern, sx_summarise, sx_pretty_print, sx_write_file). Only in-memory ops work (sx_eval, sx_build, sx_env). Without sx-tree I can't edit integration.sx to add before:init/after:init dispatch on hs-activate!. Investigated the 6 tests: 2 bootstrap (before/after init) need dispatchEvent wrapping activate; 4 parser tests require stricter parser error-rejection — `add - to` currently parses silently to `(set! nil (hs-add-to! (- 0 nil) nil))`, `on click blargh end on mouseenter also_bad` parses silently to `(do (hs-on me "click" (fn (event) blargh)) (hs-on me "mouseenter" (fn (event) also_bad)))`. Fundamental parser refactor is out of single-cluster budget regardless of sx-tree availability.
|
||||
|
||||
|
||||
125
plans/ruby-on-sx.md
Normal file
125
plans/ruby-on-sx.md
Normal file
@@ -0,0 +1,125 @@
|
||||
# Ruby-on-SX: fibers + blocks + open classes on delimited continuations
|
||||
|
||||
The headline showcase is **fibers** — Ruby's `Fiber.new { … Fiber.yield v … }` / `Fiber.resume` are textbook delimited continuations with sugar. MRI implements them by swapping C stacks; on SX they fall out of the existing `perform`/`cek-resume` machinery for free. Plus blocks/yield (lexical escape continuations, same shape as Smalltalk's non-local return), method_missing, and singleton classes.
|
||||
|
||||
End-state goal: Ruby 2.7-flavoured subset, Enumerable mixin, fibers + threads-via-fibers (no real OS threads), method_missing-driven DSLs, ~150 hand-written + classic programs.
|
||||
|
||||
## Scope decisions (defaults — override by editing before we spawn)
|
||||
|
||||
- **Syntax:** Ruby 2.7. No 3.x pattern matching, no rightward assignment, no endless methods. We pick 2.7 because it's the biggest semantic surface that still parses cleanly.
|
||||
- **Conformance:** "Reads like Ruby, runs like Ruby." Slice of RubySpec (Core + Library subset), not full RubySpec.
|
||||
- **Test corpus:** custom + curated RubySpec slice. Plus classic programs: fiber-based generator, internal DSL with method_missing, mixin-based Enumerable on a custom class.
|
||||
- **Out of scope:** real threads, GIL, refinements, `binding_of_caller` from non-Ruby contexts, Encoding object beyond UTF-8/ASCII-8BIT, RubyVM::* introspection beyond bytecode-disassembly placeholder, IO subsystem beyond `puts`/`gets`/`File.read`.
|
||||
- **Symbols:** SX symbols. Strings are mutable copies; symbols are interned.
|
||||
|
||||
## Ground rules
|
||||
|
||||
- **Scope:** only touch `lib/ruby/**` and `plans/ruby-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. Ruby primitives go in `lib/ruby/runtime.sx`.
|
||||
- **SX files:** use `sx-tree` MCP tools only.
|
||||
- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
|
||||
|
||||
## Architecture sketch
|
||||
|
||||
```
|
||||
Ruby source
|
||||
│
|
||||
▼
|
||||
lib/ruby/tokenizer.sx — keywords, ops, %w[], %i[], heredocs (deferred), regex (deferred)
|
||||
│
|
||||
▼
|
||||
lib/ruby/parser.sx — AST: classes, modules, methods, blocks, calls
|
||||
│
|
||||
▼
|
||||
lib/ruby/transpile.sx — AST → SX AST (entry: rb-eval-ast)
|
||||
│
|
||||
▼
|
||||
lib/ruby/runtime.sx — class table, MOP, dispatch, fibers, primitives
|
||||
```
|
||||
|
||||
Core mapping:
|
||||
- **Object** = SX dict `{:class :ivars :singleton-class?}`. Instance variables live in `ivars` keyed by symbol.
|
||||
- **Class** = SX dict `{:name :superclass :methods :class-methods :metaclass :includes :prepends}`. Class table is flat.
|
||||
- **Method dispatch** = lookup walks ancestor chain (prepended → class → included modules → superclass → …). Falls back to `method_missing` with a `Symbol`+args.
|
||||
- **Block** = lambda + escape continuation. `yield` invokes the block in current context. `return` from within a block invokes the enclosing-method's escape continuation.
|
||||
- **Proc** = lambda without strict arity. `Proc.new` + `proc {}`.
|
||||
- **Lambda** = lambda with strict arity + `return`-returns-from-lambda semantics.
|
||||
- **Fiber** = pair of continuations (resume-k, yield-k) wrapped in a record. `Fiber.new { … }` builds it; `Fiber.resume` invokes the resume-k; `Fiber.yield` invokes the yield-k. Built directly on `perform`/`cek-resume`.
|
||||
- **Module** = class without instance allocation. `include` puts it in the chain; `prepend` puts it earlier; `extend` puts it on the singleton.
|
||||
- **Singleton class** = lazily allocated per-object class for `def obj.foo` definitions.
|
||||
- **Symbol** = interned SX symbol. `:foo` reads as `(quote foo)` flavour.
|
||||
|
||||
## Roadmap
|
||||
|
||||
### Phase 1 — tokenizer + parser
|
||||
- [x] Tokenizer: keywords (`def end class module if unless while until do return yield begin rescue ensure case when then else elsif`), identifiers (lowercase = local/method, `@` = ivar, `@@` = cvar, `$` = global, uppercase = constant), numbers (int, float, `0x` `0o` `0b`, `_` separators), strings (`"…"` interpolation, `'…'` literal, `%w[a b c]`, `%i[a b c]`), symbols `:foo` `:"…"`, operators (`+ - * / % ** == != < > <= >= <=> === =~ !~ << >> & | ^ ~ ! && || and or not`), `:: . , ; ( ) [ ] { } -> => |`, comments `#`
|
||||
- [x] Parser: program is sequence of statements separated by newlines or `;`; method def `def name(args) … end`; class `class Foo < Bar … end`; module `module M … end`; block `do |a, b| … end` and `{ |a, b| … }`; call sugar (no parens), `obj.method`, `Mod::Const`; arg shapes (positional, default, splat `*args`, double-splat `**opts`, block `&blk`)
|
||||
- [ ] If/while/case expressions (return values), `unless`/`until`, postfix modifiers
|
||||
- [ ] Begin/rescue/ensure/retry, raise, raise with class+message
|
||||
- [x] Unit tests in `lib/ruby/tests/parse.sx`
|
||||
|
||||
### Phase 2 — object model + sequential eval
|
||||
- [ ] Class table bootstrap: `BasicObject`, `Object`, `Kernel`, `Module`, `Class`, `Numeric`, `Integer`, `Float`, `String`, `Symbol`, `Array`, `Hash`, `Range`, `NilClass`, `TrueClass`, `FalseClass`, `Proc`, `Method`
|
||||
- [ ] `rb-eval-ast`: literals, variables (local, ivar, cvar, gvar, constant), assignment (single and parallel `a, b = 1, 2`, splat receive), method call, message dispatch
|
||||
- [ ] Method lookup walks ancestor chain; cache hit-class per `(class, selector)`
|
||||
- [ ] `method_missing` fallback constructing args list
|
||||
- [ ] `super` and `super(args)` — lookup in defining class's superclass
|
||||
- [ ] Singleton class allocation on first `def obj.foo` or `class << obj`
|
||||
- [ ] `nil`, `true`, `false` are singletons of their classes; tagged values aren't boxed
|
||||
- [ ] Constant lookup (lexical-then-inheritance) with `Module.nesting`
|
||||
- [ ] 60+ tests in `lib/ruby/tests/eval.sx`
|
||||
|
||||
### Phase 3 — blocks + procs + lambdas
|
||||
- [ ] Method invocation captures escape continuation `^k` for `return`; binds it as block's escape
|
||||
- [ ] `yield` invokes implicit block
|
||||
- [ ] `block_given?`, `&blk` parameter, `&proc` arg unpacking
|
||||
- [ ] `Proc.new`, `proc { }`, `lambda { }` (or `->(x) { x }`)
|
||||
- [ ] Lambda strict arity + lambda-local `return` semantics
|
||||
- [ ] Proc lax arity (`a, b, c` unpacks Array; missing args nil)
|
||||
- [ ] `break`, `next`, `redo` — `break` is escape-from-loop-or-block; `next` is escape-from-block-iteration; `redo` re-runs current iteration
|
||||
- [ ] 30+ tests in `lib/ruby/tests/blocks.sx`
|
||||
|
||||
### Phase 4 — fibers (THE SHOWCASE)
|
||||
- [ ] `Fiber.new { |arg| … Fiber.yield v … }` allocates a fiber record with paired continuations
|
||||
- [ ] `Fiber.resume(args…)` resumes the fiber, returning the value passed to `Fiber.yield`
|
||||
- [ ] `Fiber.yield(v)` from inside the fiber suspends and returns control to the resumer
|
||||
- [ ] `Fiber.current` from inside the fiber
|
||||
- [ ] `Fiber#alive?`, `Fiber#raise` (deferred)
|
||||
- [ ] `Fiber.transfer` — symmetric coroutines (resume from any side)
|
||||
- [ ] Classic programs in `lib/ruby/tests/programs/`:
|
||||
- [ ] `generator.rb` — pull-style infinite enumerator built on fibers
|
||||
- [ ] `producer-consumer.rb` — bounded buffer with `Fiber.transfer`
|
||||
- [ ] `tree-walk.rb` — recursive tree walker that yields each node, driven by `Fiber.resume`
|
||||
- [ ] `lib/ruby/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
|
||||
|
||||
### Phase 5 — modules + mixins + metaprogramming
|
||||
- [ ] `include M` — appends M's methods after class methods in chain
|
||||
- [ ] `prepend M` — prepends M before class methods
|
||||
- [ ] `extend M` — adds M to singleton class
|
||||
- [ ] `Module#ancestors`, `Module#included_modules`
|
||||
- [ ] `define_method`, `class_eval`, `instance_eval`, `module_eval`
|
||||
- [ ] `respond_to?`, `respond_to_missing?`, `method_missing`
|
||||
- [ ] `Object#send`, `Object#public_send`, `Object#__send__`
|
||||
- [ ] `Module#method_added`, `singleton_method_added` hooks
|
||||
- [ ] Hooks: `included`, `extended`, `inherited`, `prepended`
|
||||
- [ ] Internal-DSL classic program: `lib/ruby/tests/programs/dsl.rb`
|
||||
|
||||
### Phase 6 — stdlib drive
|
||||
- [ ] `Enumerable` mixin: `each` (abstract), `map`, `select`/`filter`, `reject`, `reduce`/`inject`, `each_with_index`, `each_with_object`, `take`, `drop`, `take_while`, `drop_while`, `find`/`detect`, `find_index`, `any?`, `all?`, `none?`, `one?`, `count`, `min`, `max`, `min_by`, `max_by`, `sort`, `sort_by`, `group_by`, `partition`, `chunk`, `each_cons`, `each_slice`, `flat_map`, `lazy`
|
||||
- [ ] `Comparable` mixin: `<=>`, `<`, `<=`, `>`, `>=`, `==`, `between?`, `clamp`
|
||||
- [ ] `Array`: indexing, slicing, `push`/`pop`/`shift`/`unshift`, `concat`, `flatten`, `compact`, `uniq`, `sort`, `reverse`, `zip`, `dig`, `pack`/`unpack` (deferred)
|
||||
- [ ] `Hash`: `[]`, `[]=`, `delete`, `merge`, `each_pair`, `keys`, `values`, `to_a`, `dig`, `fetch`, default values, default proc
|
||||
- [ ] `Range`: `each`, `step`, `cover?`, `include?`, `size`, `min`, `max`
|
||||
- [ ] `String`: indexing, slicing, `split`, `gsub` (string-arg version, regex deferred), `sub`, `upcase`, `downcase`, `strip`, `chomp`, `chars`, `bytes`, `to_i`, `to_f`, `to_sym`, `*`, `+`, `<<`, format with `%`
|
||||
- [ ] `Integer`: `times`, `upto`, `downto`, `step`, `digits`, `gcd`, `lcm`
|
||||
- [ ] Drive corpus to 200+ green
|
||||
|
||||
## Progress log
|
||||
|
||||
_Newest first._
|
||||
|
||||
- 2026-04-25: Phase 1 parser complete — `lib/ruby/parser.sx` (rb-parse/rb-parse-str) + `lib/ruby/tests/parse.sx` (83/83 tests). Program, method-def (all param shapes), class/module/sclass, blocks (do/brace), method calls (parens + no-parens + chains), const-path, assignment (=, op=, massign), binary/unary ops with precedence, array/hash literals, return/yield/break/next/redo/raise, indexing.
|
||||
- 2026-04-25: Phase 1 tokenizer complete — `lib/ruby/tokenizer.sx` + `lib/ruby/tests/tokenizer.sx` (107/107 tests). Keywords, identifiers (@ivar @@cvar $gvar), numbers (dec/hex/octal/binary/float), strings (dq with interpolation kept raw, sq), symbols, %w/%i literals, operators (all compound forms), punctuation, comments, line/col tracking.
|
||||
|
||||
## Blockers
|
||||
|
||||
- _(none yet)_
|
||||
116
plans/smalltalk-on-sx.md
Normal file
116
plans/smalltalk-on-sx.md
Normal file
@@ -0,0 +1,116 @@
|
||||
# Smalltalk-on-SX: blocks with non-local return on delimited continuations
|
||||
|
||||
The headline showcase is **blocks** — Smalltalk's closures with non-local return (`^expr` aborts the enclosing *method*, not the block). Every other Smalltalk on top of a host VM (RSqueak on PyPy, GemStone on C, Maxine on Java) reinvents non-local return on whatever stack discipline the host gives them. On SX it's a one-liner: a block holds a captured continuation; `^` just invokes it. Message-passing OO falls out cheaply on top of the existing component / dispatch machinery.
|
||||
|
||||
End-state goal: ANSI-ish Smalltalk-80 subset, SUnit working, ~200 hand-written tests + a vendored slice of the Pharo kernel tests, classic corpus (eight queens, quicksort, mandelbrot, Conway's Life).
|
||||
|
||||
## Scope decisions (defaults — override by editing before we spawn)
|
||||
|
||||
- **Syntax:** Pharo / Squeak chunk format (`!` separators, `Object subclass: #Foo …`). No fileIn/fileOut images — text source only.
|
||||
- **Conformance:** ANSI X3J20 *as a target*, not bug-for-bug Squeak. "Reads like Smalltalk, runs like Smalltalk."
|
||||
- **Test corpus:** SUnit ported to SX-Smalltalk + custom programs + a curated slice of Pharo `Kernel-Tests` / `Collections-Tests`.
|
||||
- **Image:** out of scope. Source-only. No `become:` between sessions, no snapshotting.
|
||||
- **Reflection:** `class`, `respondsTo:`, `perform:`, `doesNotUnderstand:` in. `become:` (object-identity swap) **in** — it's a good CEK exercise. Method modification at runtime in.
|
||||
- **GUI / Morphic / threads:** out entirely.
|
||||
|
||||
## Ground rules
|
||||
|
||||
- **Scope:** only touch `lib/smalltalk/**` and `plans/smalltalk-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. Smalltalk primitives go in `lib/smalltalk/runtime.sx`.
|
||||
- **SX files:** use `sx-tree` MCP tools only.
|
||||
- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
|
||||
|
||||
## Architecture sketch
|
||||
|
||||
```
|
||||
Smalltalk source
|
||||
│
|
||||
▼
|
||||
lib/smalltalk/tokenizer.sx — selectors, keywords, literals, $c, #sym, #(…), $'…'
|
||||
│
|
||||
▼
|
||||
lib/smalltalk/parser.sx — AST: classes, methods, blocks, cascades, sends
|
||||
│
|
||||
▼
|
||||
lib/smalltalk/transpile.sx — AST → SX AST (entry: smalltalk-eval-ast)
|
||||
│
|
||||
▼
|
||||
lib/smalltalk/runtime.sx — class table, MOP, dispatch, primitives
|
||||
```
|
||||
|
||||
Core mapping:
|
||||
- **Class** = SX dict `{:name :superclass :ivars :methods :class-methods :metaclass}`. Class table is a flat dict keyed by class name.
|
||||
- **Object** = SX dict `{:class :ivars}` — `ivars` keyed by symbol. Tagged ints / floats / strings / symbols are not boxed; their class is looked up by SX type.
|
||||
- **Method** = SX lambda closing over a `self` binding + temps. Body wrapped in a delimited continuation so `^` can escape.
|
||||
- **Message send** = `(st-send receiver selector args)` — does class-table lookup, walks superclass chain, falls back to `doesNotUnderstand:` with a `Message` object.
|
||||
- **Block** `[:x | … ^v … ]` = lambda + captured `^k` (the method-return continuation). Invoking `^` calls `k`; outer block invocation past method return raises `BlockContext>>cannotReturn:`.
|
||||
- **Cascade** `r m1; m2; m3` = `(let ((tmp r)) (st-send tmp 'm1 ()) (st-send tmp 'm2 ()) (st-send tmp 'm3 ()))`.
|
||||
- **`ifTrue:ifFalse:` / `whileTrue:`** = ordinary block sends; the runtime intrinsifies them in the JIT path so they compile to native branches (Tier 1 of bytecode expansion already covers this pattern).
|
||||
- **`become:`** = swap two object identities everywhere — in SX this is a heap walk, but we restrict to `oneWayBecome:` (cheap: rewrite class field) by default.
|
||||
|
||||
## Roadmap
|
||||
|
||||
### Phase 1 — tokenizer + parser
|
||||
- [ ] Tokenizer: identifiers, keywords (`foo:`), binary selectors (`+`, `==`, `,`, `->`, `~=` etc.), numbers (radix `16r1F`, scaled `1.5s2`), strings `'…''…'`, characters `$c`, symbols `#foo` `#'foo bar'` `#+`, byte arrays `#[1 2 3]`, literal arrays `#(1 #foo 'x')`, comments `"…"`
|
||||
- [ ] Parser: chunk format (`! !` separators), class definitions (`Object subclass: #X instanceVariableNames: '…' classVariableNames: '…' …`), method definitions (`extend: #Foo with: 'bar ^self'`), pragmas `<primitive: 1>`, blocks `[:a :b | | t1 t2 | …]`, cascades, message precedence (unary > binary > keyword)
|
||||
- [ ] Unit tests in `lib/smalltalk/tests/parse.sx`
|
||||
|
||||
### Phase 2 — object model + sequential eval
|
||||
- [ ] Class table + bootstrap: `Object`, `Behavior`, `Class`, `Metaclass`, `UndefinedObject`, `Boolean`/`True`/`False`, `Number`/`Integer`/`Float`, `String`, `Symbol`, `Array`, `Block`
|
||||
- [ ] `smalltalk-eval-ast`: literals, variable reference, assignment, message send, cascade, sequence, return
|
||||
- [ ] Method lookup: walk class → superclass; cache hit-class on `(class, selector)`
|
||||
- [ ] `doesNotUnderstand:` fallback constructing `Message` object
|
||||
- [ ] `super` send (lookup starts at superclass of *defining* class, not receiver class)
|
||||
- [ ] 30+ tests in `lib/smalltalk/tests/eval.sx`
|
||||
|
||||
### Phase 3 — blocks + non-local return (THE SHOWCASE)
|
||||
- [ ] Method invocation captures a `^k` (the return continuation) and binds it as the block's escape
|
||||
- [ ] `^expr` from inside a block invokes that captured `^k`
|
||||
- [ ] `BlockContext>>value`, `value:`, `value:value:`, …, `valueWithArguments:`
|
||||
- [ ] `whileTrue:` / `whileTrue` / `whileFalse:` / `whileFalse` as ordinary block sends — runtime intrinsifies the loop in the bytecode JIT
|
||||
- [ ] `ifTrue:` / `ifFalse:` / `ifTrue:ifFalse:` as block sends, similarly intrinsified
|
||||
- [ ] Escape past returned-from method raises `BlockContext>>cannotReturn:`
|
||||
- [ ] Classic programs in `lib/smalltalk/tests/programs/`:
|
||||
- [ ] `eight-queens.st`
|
||||
- [ ] `quicksort.st`
|
||||
- [ ] `mandelbrot.st`
|
||||
- [ ] `life.st` (Conway's Life, glider gun)
|
||||
- [ ] `fibonacci.st` (recursive + memoised)
|
||||
- [ ] `lib/smalltalk/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
|
||||
|
||||
### Phase 4 — reflection + MOP
|
||||
- [ ] `Object>>class`, `class>>name`, `class>>superclass`, `class>>methodDict`, `class>>selectors`
|
||||
- [ ] `Object>>perform:` / `perform:with:` / `perform:withArguments:`
|
||||
- [ ] `Object>>respondsTo:`, `Object>>isKindOf:`, `Object>>isMemberOf:`
|
||||
- [ ] `Behavior>>compile:` — runtime method addition
|
||||
- [ ] `Object>>becomeForward:` (one-way become; rewrites the class field of `aReceiver`)
|
||||
- [ ] Exceptions: `Exception`, `Error`, `signal`, `signal:`, `on:do:`, `ensure:`, `ifCurtailed:` — built on top of SX `handler-bind`/`raise`
|
||||
|
||||
### Phase 5 — collections + numeric tower
|
||||
- [ ] `SequenceableCollection`/`OrderedCollection`/`Array`/`String`/`Symbol`
|
||||
- [ ] `HashedCollection`/`Set`/`Dictionary`/`IdentityDictionary`
|
||||
- [ ] `Stream` hierarchy: `ReadStream`/`WriteStream`/`ReadWriteStream`
|
||||
- [ ] `Number` tower: `SmallInteger`/`LargePositiveInteger`/`Float`/`Fraction`
|
||||
- [ ] `String>>format:`, `printOn:` for everything
|
||||
|
||||
### Phase 6 — SUnit + corpus to 200+
|
||||
- [ ] Port SUnit (TestCase, TestSuite, TestResult) — written in SX-Smalltalk, runs in itself
|
||||
- [ ] Vendor a slice of Pharo `Kernel-Tests` and `Collections-Tests`
|
||||
- [ ] Drive the scoreboard up: aim for 200+ green tests
|
||||
- [ ] Stretch: ANSI Smalltalk validator subset
|
||||
|
||||
### Phase 7 — speed (optional)
|
||||
- [ ] Method-dictionary inline caching (already in CEK as a primitive; just wire selector cache)
|
||||
- [ ] Block intrinsification beyond `whileTrue:` / `ifTrue:`
|
||||
- [ ] Compare against GNU Smalltalk on the corpus
|
||||
|
||||
## Progress log
|
||||
|
||||
_Newest first. Agent appends on every commit._
|
||||
|
||||
- _(none yet)_
|
||||
|
||||
## Blockers
|
||||
|
||||
_Shared-file issues that need someone else to fix. Minimal repro only._
|
||||
|
||||
- _(none yet)_
|
||||
127
plans/tcl-on-sx.md
Normal file
127
plans/tcl-on-sx.md
Normal file
@@ -0,0 +1,127 @@
|
||||
# Tcl-on-SX: uplevel/upvar = stack-walking delcc, everything-is-a-string
|
||||
|
||||
The headline showcase is **uplevel/upvar** — Tcl's superpower for defining your own control structures. `uplevel` evaluates a script in the *caller's* stack frame; `upvar` aliases a variable in the caller. On a normal language host this requires deep VM cooperation; on SX it falls out of the env-chain made first-class via captured continuations. Plus the *Dodekalogue* (12 rules), command-substitution everywhere, and "everything is a string" homoiconicity.
|
||||
|
||||
End-state goal: Tcl 8.6-flavoured subset, the Dodekalogue parser, namespaces, `try`/`catch`/`return -code`, `coroutine` (built on fibers), classic programs that show off uplevel-driven DSLs, ~150 hand-written tests.
|
||||
|
||||
## Scope decisions (defaults — override by editing before we spawn)
|
||||
|
||||
- **Syntax:** Tcl 8.6 surface. The 12-rule Dodekalogue. Brace-quoted scripts deferred-evaluate; double-quoted ones substitute.
|
||||
- **Conformance:** "Reads like Tcl, runs like Tcl." Slice of Tcl's own test suite, not full TCT.
|
||||
- **Test corpus:** custom + curated `tcl-tests/` slice. Plus classic programs: define-your-own `for-each-line`, expression-language compiler-in-Tcl, fiber-based event loop.
|
||||
- **Out of scope:** Tk, sockets beyond a stub, threads (mapped to `coroutine` only), `package require` of binary loadables, `dde`/`registry` Windows shims, full `clock format` locale support.
|
||||
- **Channels:** `puts` and `gets` on `stdout`/`stdin`/`stderr`; `open` on regular files; no async I/O beyond what `coroutine` gives.
|
||||
|
||||
## Ground rules
|
||||
|
||||
- **Scope:** only touch `lib/tcl/**` and `plans/tcl-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. Tcl primitives go in `lib/tcl/runtime.sx`.
|
||||
- **SX files:** use `sx-tree` MCP tools only.
|
||||
- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
|
||||
|
||||
## Architecture sketch
|
||||
|
||||
```
|
||||
Tcl source
|
||||
│
|
||||
▼
|
||||
lib/tcl/tokenizer.sx — the Dodekalogue: words, [..], ${..}, "..", {..}, ;, \n, \, #
|
||||
│
|
||||
▼
|
||||
lib/tcl/parser.sx — list-of-words AST (script = list of commands; command = list of words)
|
||||
│
|
||||
▼
|
||||
lib/tcl/transpile.sx — AST → SX AST (entry: tcl-eval-script)
|
||||
│
|
||||
▼
|
||||
lib/tcl/runtime.sx — env stack, command table, uplevel/upvar, coroutines, BIFs
|
||||
```
|
||||
|
||||
Core mapping:
|
||||
- **Value** = string. Internally we cache a "shimmer" representation (list, dict, integer, double) for performance, but every value can be re-stringified.
|
||||
- **Variable** = entry in current frame's env. Frames form a stack; level-0 is the global frame.
|
||||
- **Command** = entry in command table; first word of any list dispatches into it. User-defined via `proc`. Built-ins are SX functions registered in the table.
|
||||
- **Frame** = `{:locals (dict) :level n :parent frame}`. Each `proc` call pushes a frame; commands run in current frame.
|
||||
- **`uplevel #N script`** = walk frame chain to absolute level N (or relative if no `#`); evaluate script in that frame's env.
|
||||
- **`upvar [#N] varname localname`** = bind `localname` in the current frame as an alias to `varname` in the level-N frame (env-chain delegate).
|
||||
- **`return -code N`** = control flow as integers: 0=ok, 1=error, 2=return, 3=break, 4=continue. `catch` traps any non-zero; `try` adds named handlers.
|
||||
- **`coroutine`** = fiber on top of `perform`/`cek-resume`. `yield`/`yieldto` suspend; calling the coroutine command resumes.
|
||||
- **List / dict** = list-shaped string ("element1 element2 …") with a cached parsed form. Modifications dirty the string cache.
|
||||
|
||||
## Roadmap
|
||||
|
||||
### Phase 1 — tokenizer + parser (the Dodekalogue)
|
||||
- [ ] Tokenizer applying the 12 rules:
|
||||
1. Commands separated by `;` or newlines
|
||||
2. Words separated by whitespace within a command
|
||||
3. Double-quoted words: `\` escapes + `[…]` + `${…}` + `$var` substitution
|
||||
4. Brace-quoted words: literal, no substitution; brace count must balance
|
||||
5. Argument expansion: `{*}list`
|
||||
6. Command substitution: `[script]` evaluates script, takes its return value
|
||||
7. Variable substitution: `$name`, `${name}`, `$arr(idx)`, `$arr($i)`
|
||||
8. Backslash substitution: `\n`, `\t`, `\\`, `\xNN`, `\uNNNN`, `\<newline>` continues
|
||||
9. Comments: `#` only at the start of a command
|
||||
10. Order of substitution is left-to-right, single-pass
|
||||
11. Substitutions don't recurse — substituted text is not re-parsed
|
||||
12. The result of any substitution is the value, not a new script
|
||||
- [ ] Parser: script = list of commands; command = list of words; word = literal string + list of substitutions
|
||||
- [ ] Unit tests in `lib/tcl/tests/parse.sx`
|
||||
|
||||
### Phase 2 — sequential eval + core commands
|
||||
- [ ] `tcl-eval-script`: walk command list, dispatch each first-word into command table
|
||||
- [ ] Core commands: `set`, `unset`, `incr`, `append`, `lappend`, `puts`, `gets`, `expr`, `if`, `while`, `for`, `foreach`, `switch`, `break`, `continue`, `return`, `error`, `eval`, `subst`, `format`, `scan`
|
||||
- [ ] `expr` is its own mini-language — operator precedence, function calls (`sin`, `sqrt`, `pow`, `abs`, `int`, `double`), variable substitution, command substitution
|
||||
- [ ] String commands: `string length`, `string index`, `string range`, `string compare`, `string match`, `string toupper`, `string tolower`, `string trim`, `string map`, `string repeat`, `string first`, `string last`, `string is`, `string cat`
|
||||
- [ ] List commands: `list`, `lindex`, `lrange`, `llength`, `lreverse`, `lsearch`, `lsort`, `lsort -integer/-real/-dictionary`, `lreplace`, `linsert`, `concat`, `split`, `join`
|
||||
- [ ] Dict commands: `dict create`, `dict get`, `dict set`, `dict unset`, `dict exists`, `dict keys`, `dict values`, `dict size`, `dict for`, `dict update`, `dict merge`
|
||||
- [ ] 60+ tests in `lib/tcl/tests/eval.sx`
|
||||
|
||||
### Phase 3 — proc + uplevel + upvar (THE SHOWCASE)
|
||||
- [ ] `proc name args body` — register user-defined command; args supports defaults `{name default}` and rest `args`
|
||||
- [ ] Frame stack: each proc call pushes a frame with locals dict; pop on return
|
||||
- [ ] `uplevel ?level? script` — evaluate `script` in level-N frame's env; default level is 1 (caller). `#0` is global, `#1` is relative-1
|
||||
- [ ] `upvar ?level? otherVar localVar ?…?` — alias localVar to a variable in level-N frame; reads/writes go through the alias
|
||||
- [ ] `info level`, `info level N`, `info frame`, `info vars`, `info locals`, `info globals`, `info commands`, `info procs`, `info args`, `info body`
|
||||
- [ ] `global var ?…?` — alias to global frame (sugar for `upvar #0 var var`)
|
||||
- [ ] `variable name ?value?` — namespace-scoped global
|
||||
- [ ] Classic programs in `lib/tcl/tests/programs/`:
|
||||
- [ ] `for-each-line.tcl` — define your own loop construct using `uplevel`
|
||||
- [ ] `assert.tcl` — assertion macro that reports caller's line
|
||||
- [ ] `with-temp-var.tcl` — scoped variable rebind via `upvar`
|
||||
- [ ] `lib/tcl/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
|
||||
|
||||
### Phase 4 — control flow + error handling
|
||||
- [ ] `return -code (ok|error|return|break|continue|N) -errorinfo … -errorcode … -level N value`
|
||||
- [ ] `catch script ?resultVar? ?optionsVar?` — runs script, returns code; sets resultVar to return value/message; optionsVar to the dict
|
||||
- [ ] `try script ?on code var body ...? ?trap pattern var body...? ?finally body?`
|
||||
- [ ] `throw type message`
|
||||
- [ ] `error message ?info? ?code?`
|
||||
- [ ] Stack-trace with `errorInfo` / `errorCode`
|
||||
- [ ] 30+ tests in `lib/tcl/tests/error.sx`
|
||||
|
||||
### Phase 5 — namespaces + ensembles
|
||||
- [ ] `namespace eval ns body`, `namespace current`, `namespace which`, `namespace import`, `namespace export`, `namespace forget`, `namespace delete`
|
||||
- [ ] Qualified names: `::ns::cmd`, `::ns::var`
|
||||
- [ ] Ensembles: `namespace ensemble create -map { sub1 cmd1 sub2 cmd2 }`
|
||||
- [ ] `namespace path` for resolution chain
|
||||
- [ ] `proc` and `variable` work inside namespaces
|
||||
|
||||
### Phase 6 — coroutines + drive corpus
|
||||
- [ ] `coroutine name cmd ?args…?` — start a coroutine; future calls to `name` resume it
|
||||
- [ ] `yield ?value?` — suspend, return value to resumer
|
||||
- [ ] `yieldto cmd ?args…?` — symmetric transfer
|
||||
- [ ] `coroutine` semantics built on fibers (same delcc primitive as Ruby fibers)
|
||||
- [ ] Classic programs: `event-loop.tcl` — cooperative scheduler with multiple coroutines
|
||||
- [ ] System: `clock seconds`, `clock format`, `clock scan` (subset)
|
||||
- [ ] File I/O: `open`, `close`, `read`, `gets`, `puts -nonewline`, `flush`, `eof`, `seek`, `tell`
|
||||
- [ ] Drive corpus to 150+ green
|
||||
- [ ] Idiom corpus — `lib/tcl/tests/idioms.sx` covering classic Welch/Jones idioms
|
||||
|
||||
## Progress log
|
||||
|
||||
_Newest first._
|
||||
|
||||
- _(none yet)_
|
||||
|
||||
## Blockers
|
||||
|
||||
- _(none yet)_
|
||||
@@ -30,7 +30,7 @@ fi
|
||||
|
||||
if [ "$CLEAN" = "1" ]; then
|
||||
cd "$(dirname "$0")/.."
|
||||
for lang in lua prolog forth erlang haskell js hs; do
|
||||
for lang in lua prolog forth erlang haskell js hs smalltalk common-lisp apl ruby tcl; do
|
||||
wt="$WORKTREE_BASE/$lang"
|
||||
if [ -d "$wt" ]; then
|
||||
git worktree remove --force "$wt" 2>/dev/null || rm -rf "$wt"
|
||||
@@ -39,5 +39,5 @@ if [ "$CLEAN" = "1" ]; then
|
||||
done
|
||||
git worktree prune
|
||||
echo "Worktree branches (loops/<lang>) are preserved. Delete manually if desired:"
|
||||
echo " git branch -D loops/lua loops/prolog loops/forth loops/erlang loops/haskell loops/js loops/hs"
|
||||
echo " git branch -D loops/lua loops/prolog loops/forth loops/erlang loops/haskell loops/js loops/hs loops/smalltalk loops/common-lisp loops/apl loops/ruby loops/tcl"
|
||||
fi
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
#!/usr/bin/env bash
|
||||
# Spawn 7 claude sessions in tmux, one per language loop.
|
||||
# Spawn 12 claude sessions in tmux, one per language loop.
|
||||
# Each runs in its own git worktree rooted at /root/rose-ash-loops/<lang>,
|
||||
# on branch loops/<lang>. No two loops share a working tree, so there's
|
||||
# zero risk of file collisions between languages.
|
||||
@@ -9,7 +9,7 @@
|
||||
#
|
||||
# After the script prints done:
|
||||
# tmux a -t sx-loops
|
||||
# Ctrl-B + <window-number> to switch (0=lua ... 6=hs)
|
||||
# Ctrl-B + <window-number> to switch (0=lua ... 11=tcl)
|
||||
# Ctrl-B + d to detach (loops keep running, SSH-safe)
|
||||
#
|
||||
# Stop: ./scripts/sx-loops-down.sh
|
||||
@@ -38,8 +38,13 @@ declare -A BRIEFING=(
|
||||
[haskell]=haskell-loop.md
|
||||
[js]=loop.md
|
||||
[hs]=hs-loop.md
|
||||
[smalltalk]=smalltalk-loop.md
|
||||
[common-lisp]=common-lisp-loop.md
|
||||
[apl]=apl-loop.md
|
||||
[ruby]=ruby-loop.md
|
||||
[tcl]=tcl-loop.md
|
||||
)
|
||||
ORDER=(lua prolog forth erlang haskell js hs)
|
||||
ORDER=(lua prolog forth erlang haskell js hs smalltalk common-lisp apl ruby tcl)
|
||||
|
||||
mkdir -p "$WORKTREE_BASE"
|
||||
|
||||
@@ -60,13 +65,13 @@ for lang in "${ORDER[@]}"; do
|
||||
fi
|
||||
done
|
||||
|
||||
# Create tmux session with 7 windows, each cwd in its worktree
|
||||
# Create tmux session with one window per language, each cwd in its worktree
|
||||
tmux new-session -d -s "$SESSION" -n "${ORDER[0]}" -c "$WORKTREE_BASE/${ORDER[0]}"
|
||||
for lang in "${ORDER[@]:1}"; do
|
||||
tmux new-window -t "$SESSION" -n "$lang" -c "$WORKTREE_BASE/$lang"
|
||||
done
|
||||
|
||||
echo "Starting 7 claude sessions..."
|
||||
echo "Starting ${#ORDER[@]} claude sessions..."
|
||||
for lang in "${ORDER[@]}"; do
|
||||
tmux send-keys -t "$SESSION:$lang" "claude" C-m
|
||||
done
|
||||
@@ -89,10 +94,10 @@ for lang in "${ORDER[@]}"; do
|
||||
done
|
||||
|
||||
echo ""
|
||||
echo "Done. 7 loops started in tmux session '$SESSION', each in its own worktree."
|
||||
echo "Done. ${#ORDER[@]} loops started in tmux session '$SESSION', each in its own worktree."
|
||||
echo ""
|
||||
echo " Attach: tmux a -t $SESSION"
|
||||
echo " Switch: Ctrl-B <0..6> (0=lua 1=prolog 2=forth 3=erlang 4=haskell 5=js 6=hs)"
|
||||
echo " Switch: Ctrl-B <0..11> (0=lua 1=prolog 2=forth 3=erlang 4=haskell 5=js 6=hs 7=smalltalk 8=common-lisp 9=apl 10=ruby 11=tcl)"
|
||||
echo " List: Ctrl-B w"
|
||||
echo " Detach: Ctrl-B d"
|
||||
echo " Stop: ./scripts/sx-loops-down.sh"
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -19,7 +19,6 @@
|
||||
(define
|
||||
reserved
|
||||
(list
|
||||
(quote beingTold)
|
||||
(quote me)
|
||||
(quote it)
|
||||
(quote event)
|
||||
@@ -66,10 +65,7 @@
|
||||
(list (quote me))
|
||||
(list
|
||||
(quote let)
|
||||
(list
|
||||
(list (quote beingTold) (quote me))
|
||||
(list (quote it) nil)
|
||||
(list (quote event) nil))
|
||||
(list (list (quote it) nil) (list (quote event) nil))
|
||||
guarded))))))))))
|
||||
|
||||
;; ── Activate a single element ───────────────────────────────────
|
||||
@@ -77,65 +73,23 @@
|
||||
;; Marks the element to avoid double-activation.
|
||||
|
||||
(define
|
||||
hs-register-scripts!
|
||||
hs-activate!
|
||||
(fn
|
||||
()
|
||||
(for-each
|
||||
(fn
|
||||
(script)
|
||||
(when
|
||||
(not (dom-get-data script "hs-script-loaded"))
|
||||
(let
|
||||
((src (host-get script "innerHTML")))
|
||||
(when
|
||||
(and src (not (= src "")))
|
||||
(guard
|
||||
(_e (true nil))
|
||||
(eval-expr-cek (hs-to-sx-from-source src)))
|
||||
(dom-set-data script "hs-script-loaded" true)))))
|
||||
(hs-query-all "script[type=text/hyperscript]"))))
|
||||
(el)
|
||||
(let
|
||||
((src (dom-get-attr el "_")) (prev (dom-get-data el "hs-script")))
|
||||
(when
|
||||
(and src (not (= src prev)))
|
||||
(hs-log-event! "hyperscript:init")
|
||||
(dom-set-data el "hs-script" src)
|
||||
(dom-set-data el "hs-active" true)
|
||||
(dom-set-attr el "data-hyperscript-powered" "true")
|
||||
(let ((handler (hs-handler src))) (handler el))))))
|
||||
|
||||
;; ── Boot: scan entire document ──────────────────────────────────
|
||||
;; Called once at page load. Finds all elements with _ attribute,
|
||||
;; compiles their hyperscript, and activates them.
|
||||
|
||||
(define
|
||||
hs-activate!
|
||||
(fn
|
||||
(el)
|
||||
(do
|
||||
(hs-register-scripts!)
|
||||
(let
|
||||
((src (dom-get-attr el "_")) (prev (dom-get-data el "hs-script")))
|
||||
(when
|
||||
(and src (not (= src prev)))
|
||||
(when
|
||||
(dom-dispatch el "hyperscript:before:init" nil)
|
||||
(hs-log-event! "hyperscript:init")
|
||||
(dom-set-data el "hs-script" src)
|
||||
(dom-set-data el "hs-active" true)
|
||||
(dom-set-attr el "data-hyperscript-powered" "true")
|
||||
(guard
|
||||
(_e (true nil))
|
||||
(let
|
||||
((handler (hs-handler src)))
|
||||
(let
|
||||
((el-type (dom-get-attr el "type"))
|
||||
(comp-name (dom-get-attr el "component")))
|
||||
(let
|
||||
((safe-handler (fn (e) (host-call-fn handler (list e)))))
|
||||
(if
|
||||
(= el-type "text/hyperscript-template")
|
||||
(for-each
|
||||
safe-handler
|
||||
(hs-query-all (or comp-name "")))
|
||||
(safe-handler el))))))
|
||||
(dom-dispatch el "hyperscript:after:init" nil)))))))
|
||||
|
||||
;; ── Boot subtree: for dynamic content ───────────────────────────
|
||||
;; Called after HTMX swaps or dynamic DOM insertion.
|
||||
;; Only activates elements within the given root.
|
||||
|
||||
(define
|
||||
hs-deactivate!
|
||||
(fn
|
||||
@@ -147,6 +101,10 @@
|
||||
(dom-set-data el "hs-active" false)
|
||||
(dom-set-data el "hs-script" nil))))
|
||||
|
||||
;; ── Boot subtree: for dynamic content ───────────────────────────
|
||||
;; Called after HTMX swaps or dynamic DOM insertion.
|
||||
;; Only activates elements within the given root.
|
||||
|
||||
(define
|
||||
hs-boot!
|
||||
(fn
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -28,27 +28,6 @@
|
||||
|
||||
(define hs-ws? (fn (c) (or (= c " ") (= c "\t") (= c "\n") (= c "\r"))))
|
||||
|
||||
(define
|
||||
hs-hex-digit?
|
||||
(fn
|
||||
(c)
|
||||
(or
|
||||
(and (>= c "0") (<= c "9"))
|
||||
(and (>= c "a") (<= c "f"))
|
||||
(and (>= c "A") (<= c "F")))))
|
||||
|
||||
(define
|
||||
hs-hex-val
|
||||
(fn
|
||||
(c)
|
||||
(let
|
||||
((code (char-code c)))
|
||||
(cond
|
||||
((and (>= code 48) (<= code 57)) (- code 48))
|
||||
((and (>= code 65) (<= code 70)) (- code 55))
|
||||
((and (>= code 97) (<= code 102)) (- code 87))
|
||||
(true 0)))))
|
||||
|
||||
;; ── Keyword set ───────────────────────────────────────────────────
|
||||
|
||||
(define
|
||||
@@ -131,7 +110,6 @@
|
||||
"append"
|
||||
"settle"
|
||||
"transition"
|
||||
"view"
|
||||
"over"
|
||||
"closest"
|
||||
"next"
|
||||
@@ -209,8 +187,7 @@
|
||||
"using"
|
||||
"giving"
|
||||
"ask"
|
||||
"answer"
|
||||
"bind"))
|
||||
"answer"))
|
||||
|
||||
(define hs-keyword? (fn (word) (some (fn (k) (= k word)) hs-keywords)))
|
||||
|
||||
@@ -258,15 +235,10 @@
|
||||
read-number
|
||||
(fn
|
||||
(start)
|
||||
(define
|
||||
read-int
|
||||
(fn
|
||||
()
|
||||
(when
|
||||
(and (< pos src-len) (hs-digit? (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(read-int))))
|
||||
(read-int)
|
||||
(when
|
||||
(and (< pos src-len) (hs-digit? (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(read-number start))
|
||||
(when
|
||||
(and
|
||||
(< pos src-len)
|
||||
@@ -274,7 +246,15 @@
|
||||
(< (+ pos 1) src-len)
|
||||
(hs-digit? (hs-peek 1)))
|
||||
(hs-advance! 1)
|
||||
(read-int))
|
||||
(define
|
||||
read-frac
|
||||
(fn
|
||||
()
|
||||
(when
|
||||
(and (< pos src-len) (hs-digit? (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(read-frac))))
|
||||
(read-frac))
|
||||
(do
|
||||
(when
|
||||
(and
|
||||
@@ -292,7 +272,15 @@
|
||||
(< pos src-len)
|
||||
(or (= (hs-cur) "+") (= (hs-cur) "-")))
|
||||
(hs-advance! 1))
|
||||
(read-int))
|
||||
(define
|
||||
read-exp-digits
|
||||
(fn
|
||||
()
|
||||
(when
|
||||
(and (< pos src-len) (hs-digit? (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(read-exp-digits))))
|
||||
(read-exp-digits))
|
||||
(let
|
||||
((num-end pos))
|
||||
(when
|
||||
@@ -320,7 +308,7 @@
|
||||
()
|
||||
(cond
|
||||
(>= pos src-len)
|
||||
(error "Unterminated string")
|
||||
nil
|
||||
(= (hs-cur) "\\")
|
||||
(do
|
||||
(hs-advance! 1)
|
||||
@@ -330,47 +318,15 @@
|
||||
((ch (hs-cur)))
|
||||
(cond
|
||||
(= ch "n")
|
||||
(do (append! chars "\n") (hs-advance! 1))
|
||||
(append! chars "\n")
|
||||
(= ch "t")
|
||||
(do (append! chars "\t") (hs-advance! 1))
|
||||
(= ch "r")
|
||||
(do (append! chars "\r") (hs-advance! 1))
|
||||
(= ch "b")
|
||||
(do
|
||||
(append! chars (char-from-code 8))
|
||||
(hs-advance! 1))
|
||||
(= ch "f")
|
||||
(do
|
||||
(append! chars (char-from-code 12))
|
||||
(hs-advance! 1))
|
||||
(= ch "v")
|
||||
(do
|
||||
(append! chars (char-from-code 11))
|
||||
(hs-advance! 1))
|
||||
(append! chars "\t")
|
||||
(= ch "\\")
|
||||
(do (append! chars "\\") (hs-advance! 1))
|
||||
(append! chars "\\")
|
||||
(= ch quote-char)
|
||||
(do (append! chars quote-char) (hs-advance! 1))
|
||||
(= ch "x")
|
||||
(do
|
||||
(hs-advance! 1)
|
||||
(if
|
||||
(and
|
||||
(< (+ pos 1) src-len)
|
||||
(hs-hex-digit? (hs-cur))
|
||||
(hs-hex-digit? (hs-peek 1)))
|
||||
(let
|
||||
((d1 (hs-hex-val (hs-cur)))
|
||||
(d2 (hs-hex-val (hs-peek 1))))
|
||||
(append!
|
||||
chars
|
||||
(char-from-code (+ (* d1 16) d2)))
|
||||
(hs-advance! 2))
|
||||
(error "Invalid hexadecimal escape: \\x")))
|
||||
:else (do
|
||||
(append! chars "\\")
|
||||
(append! chars ch)
|
||||
(hs-advance! 1)))))
|
||||
(append! chars quote-char)
|
||||
:else (do (append! chars "\\") (append! chars ch)))
|
||||
(hs-advance! 1)))
|
||||
(loop))
|
||||
(= (hs-cur) quote-char)
|
||||
(hs-advance! 1)
|
||||
@@ -457,68 +413,27 @@
|
||||
read-class-name
|
||||
(fn
|
||||
(start)
|
||||
(define
|
||||
build-name
|
||||
(fn
|
||||
(acc depth)
|
||||
(cond
|
||||
((and (< pos src-len) (= (hs-cur) "\\") (< (+ pos 1) src-len))
|
||||
(do
|
||||
(hs-advance! 1)
|
||||
(let
|
||||
((c (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(build-name (str acc c) depth))))
|
||||
((and (< pos src-len) (= (hs-cur) "["))
|
||||
(do
|
||||
(let
|
||||
((c (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(build-name (str acc c) (+ depth 1)))))
|
||||
((and (< pos src-len) (= (hs-cur) "]"))
|
||||
(do
|
||||
(let
|
||||
((c (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(build-name
|
||||
(str acc c)
|
||||
(if (> depth 0) (- depth 1) 0)))))
|
||||
((and (< pos src-len) (> depth 0) (or (= (hs-cur) "(") (= (hs-cur) ")")))
|
||||
(do
|
||||
(let
|
||||
((c (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(build-name (str acc c) depth))))
|
||||
((and (< pos src-len) (or (hs-ident-char? (hs-cur)) (= (hs-cur) ":") (= (hs-cur) "&")))
|
||||
(do
|
||||
(let
|
||||
((c (hs-cur)))
|
||||
(hs-advance! 1)
|
||||
(build-name (str acc c) depth))))
|
||||
(true acc))))
|
||||
(build-name "" 0)))
|
||||
(when
|
||||
(and
|
||||
(< pos src-len)
|
||||
(or
|
||||
(hs-ident-char? (hs-cur))
|
||||
(= (hs-cur) ":")
|
||||
(= (hs-cur) "[")
|
||||
(= (hs-cur) "]")))
|
||||
(hs-advance! 1)
|
||||
(read-class-name start))
|
||||
(slice src start pos)))
|
||||
(define
|
||||
hs-emit!
|
||||
(fn
|
||||
(type value start)
|
||||
(let
|
||||
((tok (hs-make-token type value start))
|
||||
(end-pos
|
||||
(max pos (+ start (if (nil? value) 0 (len (str value)))))))
|
||||
(do
|
||||
(dict-set! tok "end" end-pos)
|
||||
(dict-set! tok "line" (len (split (slice src 0 start) "\n")))
|
||||
(append! tokens tok)))))
|
||||
(append! tokens (hs-make-token type value start))))
|
||||
(define
|
||||
scan!
|
||||
(fn
|
||||
()
|
||||
(let
|
||||
((ws-start pos))
|
||||
(skip-ws!)
|
||||
(when
|
||||
(and (> (len tokens) 0) (> pos ws-start))
|
||||
(hs-emit! "whitespace" (slice src ws-start pos) ws-start)))
|
||||
(skip-ws!)
|
||||
(when
|
||||
(< pos src-len)
|
||||
(let
|
||||
@@ -542,21 +457,6 @@
|
||||
(do (hs-emit! "selector" (read-selector) start) (scan!))
|
||||
(and (= ch ".") (< (+ pos 1) src-len) (= (hs-peek 1) "."))
|
||||
(do (hs-emit! "op" ".." start) (hs-advance! 2) (scan!))
|
||||
(and
|
||||
(= ch ".")
|
||||
(< (+ pos 1) src-len)
|
||||
(or
|
||||
(hs-letter? (hs-peek 1))
|
||||
(= (hs-peek 1) "-")
|
||||
(= (hs-peek 1) "_"))
|
||||
(> (len tokens) 0)
|
||||
(let
|
||||
((lt (dict-get (nth tokens (- (len tokens) 1)) :type)))
|
||||
(or
|
||||
(= lt "paren-close")
|
||||
(= lt "brace-close")
|
||||
(= lt "bracket-close"))))
|
||||
(do (hs-emit! "dot" "." start) (hs-advance! 1) (scan!))
|
||||
(and
|
||||
(= ch ".")
|
||||
(< (+ pos 1) src-len)
|
||||
@@ -568,18 +468,6 @@
|
||||
(hs-advance! 1)
|
||||
(hs-emit! "class" (read-class-name pos) start)
|
||||
(scan!))
|
||||
(and
|
||||
(= ch "#")
|
||||
(< (+ pos 1) src-len)
|
||||
(hs-ident-start? (hs-peek 1))
|
||||
(> (len tokens) 0)
|
||||
(let
|
||||
((lt (dict-get (nth tokens (- (len tokens) 1)) :type)))
|
||||
(or
|
||||
(= lt "paren-close")
|
||||
(= lt "brace-close")
|
||||
(= lt "bracket-close"))))
|
||||
(do (hs-emit! "op" "#" start) (hs-advance! 1) (scan!))
|
||||
(and
|
||||
(= ch "#")
|
||||
(< (+ pos 1) src-len)
|
||||
@@ -648,12 +536,10 @@
|
||||
(do
|
||||
(let
|
||||
((word (read-ident start)))
|
||||
(let
|
||||
((full-word (if (and (< pos src-len) (= (hs-cur) "'") (< (+ pos 1) src-len) (hs-letter? (hs-peek 1)) (not (and (= (hs-peek 1) "s") (or (>= (+ pos 2) src-len) (not (hs-ident-char? (hs-peek 2))))))) (do (hs-advance! 1) (str word "'" (read-ident pos))) word)))
|
||||
(hs-emit!
|
||||
(if (hs-keyword? full-word) "keyword" "ident")
|
||||
full-word
|
||||
start)))
|
||||
(hs-emit!
|
||||
(if (hs-keyword? word) "keyword" "ident")
|
||||
word
|
||||
start))
|
||||
(scan!))
|
||||
(and
|
||||
(or (= ch "=") (= ch "!") (= ch "<") (= ch ">"))
|
||||
@@ -734,82 +620,7 @@
|
||||
(do (hs-emit! "colon" ":" start) (hs-advance! 1) (scan!))
|
||||
(= ch "|")
|
||||
(do (hs-emit! "op" "|" start) (hs-advance! 1) (scan!))
|
||||
(= ch "&")
|
||||
(do (hs-emit! "op" "&" start) (hs-advance! 1) (scan!))
|
||||
(= ch "#")
|
||||
(do (hs-emit! "op" "#" start) (hs-advance! 1) (scan!))
|
||||
(= ch "?")
|
||||
(do (hs-emit! "op" "?" start) (hs-advance! 1) (scan!))
|
||||
(= ch ";")
|
||||
(do (hs-emit! "op" ";" start) (hs-advance! 1) (scan!))
|
||||
:else (do (hs-advance! 1) (scan!)))))))
|
||||
(scan!)
|
||||
(hs-emit! "eof" nil pos)
|
||||
tokens)))
|
||||
|
||||
;; ── Template-mode tokenizer (E37 API) ────────────────────────────────
|
||||
;; Used by hs-tokens-of when :template flag is set.
|
||||
;; Emits outer " chars as single STRING tokens; ${ ... } as $ { <inner-tokens> };
|
||||
;; inner content is tokenized with the regular hs-tokenize.
|
||||
|
||||
(define
|
||||
hs-tokenize-template
|
||||
(fn
|
||||
(src)
|
||||
(let
|
||||
((tokens (list)) (pos 0) (src-len (len src)))
|
||||
(define t-cur (fn () (if (< pos src-len) (nth src pos) nil)))
|
||||
(define t-peek (fn (n) (if (< (+ pos n) src-len) (nth src (+ pos n)) nil)))
|
||||
(define t-advance! (fn (n) (set! pos (+ pos n))))
|
||||
(define t-emit! (fn (type value) (append! tokens (hs-make-token type value pos))))
|
||||
(define
|
||||
scan-to-close!
|
||||
(fn
|
||||
(depth)
|
||||
(when
|
||||
(and (< pos src-len) (> depth 0))
|
||||
(cond
|
||||
(= (t-cur) "{")
|
||||
(do (t-advance! 1) (scan-to-close! (+ depth 1)))
|
||||
(= (t-cur) "}")
|
||||
(when (> (- depth 1) 0) (t-advance! 1) (scan-to-close! (- depth 1)))
|
||||
:else (do (t-advance! 1) (scan-to-close! depth))))))
|
||||
(define
|
||||
scan-template!
|
||||
(fn
|
||||
()
|
||||
(when
|
||||
(< pos src-len)
|
||||
(let
|
||||
((ch (t-cur)))
|
||||
(cond
|
||||
(= ch "\"")
|
||||
(do (t-emit! "string" "\"") (t-advance! 1) (scan-template!))
|
||||
(and (= ch "$") (= (t-peek 1) "{"))
|
||||
(do
|
||||
(t-emit! "op" "$")
|
||||
(t-advance! 1)
|
||||
(t-emit! "brace-open" "{")
|
||||
(t-advance! 1)
|
||||
(let
|
||||
((inner-start pos))
|
||||
(scan-to-close! 1)
|
||||
(let
|
||||
((inner-src (slice src inner-start pos))
|
||||
(inner-toks (hs-tokenize inner-src)))
|
||||
(for-each
|
||||
(fn (tok)
|
||||
(when (not (= (get tok "type") "eof"))
|
||||
(append! tokens tok)))
|
||||
inner-toks))
|
||||
(t-emit! "brace-close" "}")
|
||||
(when (< pos src-len) (t-advance! 1)))
|
||||
(scan-template!))
|
||||
(= ch "$")
|
||||
(do (t-emit! "op" "$") (t-advance! 1) (scan-template!))
|
||||
(hs-ws? ch)
|
||||
(do (t-advance! 1) (scan-template!))
|
||||
:else (do (t-advance! 1) (scan-template!)))))))
|
||||
(scan-template!)
|
||||
(t-emit! "eof" nil)
|
||||
tokens)))
|
||||
@@ -46045,7 +46045,7 @@ d2=133,bi=102,bh="Re__Hash_set",cA="Stdlib__Type",cB=114,fF="Stdlib__Buffer",dX=
|
||||
}
|
||||
return trampoline(eval_expr(Sx_types[75].call(null, mac), local));
|
||||
}
|
||||
var step_limit = [0, 0], step_count = [0, 0], _wc_check = 0;
|
||||
var step_limit = [0, 0], step_count = [0, 0];
|
||||
function cek_step_loop(state$0){
|
||||
var state = state$0;
|
||||
for(;;){
|
||||
@@ -46055,11 +46055,6 @@ d2=133,bi=102,bh="Re__Hash_set",cA="Stdlib__Type",cB=114,fF="Stdlib__Buffer",dX=
|
||||
throw caml_maybe_attach_backtrace
|
||||
([0, Sx_types[9], "TIMEOUT: step limit exceeded"], 1);
|
||||
}
|
||||
if(++_wc_check >= 10000){ _wc_check = 0;
|
||||
if(globalThis.__hs_deadline && Date.now() > globalThis.__hs_deadline)
|
||||
throw caml_maybe_attach_backtrace
|
||||
([0, Sx_types[9], "TIMEOUT: wall clock exceeded"], 1);
|
||||
}
|
||||
var
|
||||
or = cek_terminal_p(state),
|
||||
or$0 = Sx_types[56].call(null, or) ? or : cek_suspended_p(state);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,263 +0,0 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* Evaluate SX (or inspect HS compiler/parser output) in the full WASM kernel.
|
||||
*
|
||||
* Environment variables (preferred — avoids shell escaping):
|
||||
* HS_EVAL_EXPR SX expression to evaluate (required unless --expr arg given)
|
||||
* HS_EVAL_SETUP SX setup expression run before main eval
|
||||
* HS_EVAL_FILES Comma-separated list of .sx files to load first
|
||||
* HS_EVAL_MODE 'eval' (default) | 'compile' | 'parse'
|
||||
* compile: wraps expr as hs-compile arg, returns SX AST string
|
||||
* parse: wraps expr as hs-parse arg, returns parse tree string
|
||||
*
|
||||
* CLI fallback: first positional arg used as expression if HS_EVAL_EXPR not set.
|
||||
*
|
||||
* Output: JSON to stdout { ok: true, result: "..." }
|
||||
* or { ok: false, error: "..." }
|
||||
* Progress / load errors go to stderr.
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
|
||||
const PROJECT = path.resolve(__dirname, '..');
|
||||
const WASM_DIR = path.join(PROJECT, 'shared/static/wasm');
|
||||
const SX_DIR = path.join(WASM_DIR, 'sx');
|
||||
|
||||
// ── Load WASM kernel ────────────────────────────────────────────
|
||||
eval(fs.readFileSync(path.join(WASM_DIR, 'sx_browser.bc.js'), 'utf8'));
|
||||
const K = globalThis.SxKernel;
|
||||
|
||||
// ── Minimal DOM mock ────────────────────────────────────────────
|
||||
class CL {
|
||||
constructor() { this._s = new Set(); }
|
||||
add(c) { if (c) this._s.add(c); }
|
||||
remove(c) { this._s.delete(c); }
|
||||
contains(c) { return this._s.has(c); }
|
||||
toggle(c) { this._s.has(c) ? this.remove(c) : this.add(c); return this._s.has(c); }
|
||||
_sync(v) { this._s = new Set((v||'').split(' ').filter(Boolean)); }
|
||||
}
|
||||
class El {
|
||||
constructor(t) {
|
||||
this.tagName = t.toUpperCase(); this.nodeName = this.tagName; this.nodeType = 1;
|
||||
this.id = ''; this.className = ''; this.textContent = ''; this.innerHTML = '';
|
||||
this.value = ''; this.checked = false; this.disabled = false; this.type = '';
|
||||
this.style = { setProperty(p,v){this[p]=v;}, getPropertyValue(p){return this[p]||'';} };
|
||||
this.attributes = {}; this.children = []; this.childNodes = [];
|
||||
this.childNodes.item = i => this.childNodes[i] || null;
|
||||
this.parentNode = null; this.parentElement = null; this._listeners = {};
|
||||
this.classList = new CL();
|
||||
this.dataset = {};
|
||||
this.open = false; this.multiple = false; this.selected = false;
|
||||
}
|
||||
setAttribute(n,v) {
|
||||
this.attributes[n] = String(v);
|
||||
if (n==='id') this.id = v;
|
||||
if (n==='class') { this.className = v; this.classList._sync(v); }
|
||||
if (n==='value') this.value = v;
|
||||
}
|
||||
getAttribute(n) { return this.attributes[n] !== undefined ? this.attributes[n] : null; }
|
||||
removeAttribute(n){ delete this.attributes[n]; }
|
||||
hasAttribute(n) { return n in this.attributes; }
|
||||
appendChild(c) { if(c){ c.parentNode=this; c.parentElement=this; this.children.push(c); this.childNodes.push(c); } return c; }
|
||||
removeChild(c) { this.children=this.children.filter(x=>x!==c); this.childNodes=this.childNodes.filter(x=>x!==c); if(c){c.parentNode=null;c.parentElement=null;} return c; }
|
||||
remove() { if(this.parentNode) this.parentNode.removeChild(this); }
|
||||
prepend(c) { if(c){ c.parentNode=this; this.children.unshift(c); this.childNodes.unshift(c); } }
|
||||
insertBefore(c,r) { if(!r) return this.appendChild(c); const i=this.childNodes.indexOf(r); if(i<0) return this.appendChild(c); this.childNodes.splice(i,0,c); this.children.splice(i,0,c); c.parentNode=this; return c; }
|
||||
replaceChild(n,o) { const i=this.childNodes.indexOf(o); if(i>=0){ this.childNodes[i]=n; this.children[i]=n; n.parentNode=this; o.parentNode=null; } return o; }
|
||||
cloneNode(deep) { const c=new El(this.tagName); if(deep) for(const ch of this.childNodes) c.appendChild(ch.cloneNode&&ch.cloneNode(true)||{...ch}); return c; }
|
||||
addEventListener(t,h) { if(!this._listeners[t]) this._listeners[t]=[]; this._listeners[t].push(h); }
|
||||
removeEventListener(t,h) { if(this._listeners[t]) this._listeners[t]=this._listeners[t].filter(x=>x!==h); }
|
||||
dispatchEvent(ev) { (this._listeners[ev&&ev.type]||[]).forEach(h=>{ try{h(ev);}catch(e){} }); return true; }
|
||||
querySelector(sel) {
|
||||
if (!sel) return null;
|
||||
if (sel.startsWith('#')) { const id=sel.slice(1); if(this.id===id) return this; for(const c of this.childNodes){const r=c.querySelector&&c.querySelector(sel); if(r) return r;} return null; }
|
||||
return null;
|
||||
}
|
||||
querySelectorAll() { return []; }
|
||||
closest(sel) { return sel && this.matches(sel) ? this : (this.parentNode && this.parentNode.closest ? this.parentNode.closest(sel) : null); }
|
||||
matches(sel) {
|
||||
if (!sel) return false;
|
||||
if (sel.startsWith('#')) return this.id === sel.slice(1);
|
||||
if (sel.startsWith('.')) return this.classList.contains(sel.slice(1));
|
||||
return this.tagName.toLowerCase() === sel.toLowerCase();
|
||||
}
|
||||
focus() {}
|
||||
blur() {}
|
||||
click() { this.dispatchEvent(new Ev('click',{bubbles:true})); }
|
||||
getBoundingClientRect() { return {width:0,height:0,top:0,left:0,right:0,bottom:0}; }
|
||||
}
|
||||
class Ev {
|
||||
constructor(t,o) { this.type=t; const opts=o||{}; this.bubbles=opts.bubbles!==false; this.detail=opts.detail||null; this.target=null; this.currentTarget=null; }
|
||||
preventDefault() {}
|
||||
stopPropagation() {}
|
||||
}
|
||||
|
||||
const _body = new El('body');
|
||||
const _head = new El('head');
|
||||
const _docListeners = {};
|
||||
const _domRegistry = new Map(); // id -> El
|
||||
|
||||
function _findById(id) {
|
||||
function find(el) {
|
||||
if (!(el instanceof El)) return null;
|
||||
if (el.id === id) return el;
|
||||
for (const c of (el.childNodes||[])) { const r = find(c); if (r) return r; }
|
||||
return null;
|
||||
}
|
||||
return find(_body);
|
||||
}
|
||||
|
||||
globalThis.document = {
|
||||
body: _body, head: _head, title: '',
|
||||
createElement: t => new El(t),
|
||||
createElementNS: (ns,t) => new El(t),
|
||||
createTextNode: s => ({ nodeType:3, textContent:String(s||''), nodeName:'#text', parentNode:null }),
|
||||
createDocumentFragment: () => { const f=new El('fragment'); f.nodeType=11; return f; },
|
||||
createComment: s => ({ nodeType:8, textContent:s, nodeName:'#comment' }),
|
||||
getElementById: id => _findById(id),
|
||||
querySelector: sel => sel && sel.startsWith('#') ? _findById(sel.slice(1)) : null,
|
||||
querySelectorAll: () => [],
|
||||
addEventListener: (t,h) => { if(!_docListeners[t]) _docListeners[t]=[]; _docListeners[t].push(h); },
|
||||
removeEventListener: (t,h) => { if(_docListeners[t]) _docListeners[t]=_docListeners[t].filter(x=>x!==h); },
|
||||
dispatchEvent: ev => { (_docListeners[ev&&ev.type]||[]).forEach(h=>{ try{h(ev);}catch(e){} }); },
|
||||
activeElement: null,
|
||||
};
|
||||
globalThis.CustomEvent = Ev;
|
||||
globalThis.Event = Ev;
|
||||
globalThis.window = globalThis;
|
||||
try { globalThis.navigator = { userAgent: 'node' }; } catch(e) { Object.defineProperty(globalThis, 'navigator', { value: { userAgent: 'node' }, writable: true, configurable: true }); }
|
||||
globalThis.location = { href:'http://localhost/', pathname:'/', search:'', hash:'' };
|
||||
globalThis.history = { pushState(){}, replaceState(){} };
|
||||
globalThis.getSelection = () => ({ toString: () => '' });
|
||||
globalThis.console = { log:()=>{}, error:()=>{}, warn:()=>{}, info:()=>{}, debug:()=>{} };
|
||||
globalThis.ResizeObserver = class { observe(){} unobserve(){} disconnect(){} };
|
||||
globalThis.IntersectionObserver = class { constructor(cb){} observe(){} unobserve(){} disconnect(){} takeRecords(){return[];} };
|
||||
|
||||
// ── FFI registrations ───────────────────────────────────────────
|
||||
K.registerNative('hs-ref-eq', a => a[0]===a[1]);
|
||||
K.registerNative('host-global', a => { const n=a[0]; return (n in globalThis)?globalThis[n]:null; });
|
||||
K.registerNative('host-get', a => {
|
||||
if (a[0]==null) return null;
|
||||
if (a[0] && a[0]._type==='list' && (a[1]==='length'||a[1]==='size')) return a[0].items.length;
|
||||
if (a[0] instanceof El && a[1]==='innerText') return String(a[0].textContent||'');
|
||||
const v = a[0][a[1]]; return v===undefined ? null : v;
|
||||
});
|
||||
K.registerNative('host-set!', a => { if(a[0]!=null){ a[0][a[1]]=a[2]; if(a[0] instanceof El && a[1]==='id' && a[2]) a[0].id=a[2]; } return a[2]; });
|
||||
K.registerNative('host-call', a => {
|
||||
const [o,m,...r]=a;
|
||||
if(o==null){ const f=globalThis[m]; return typeof f==='function'?f.apply(null,r):null; }
|
||||
if(o && typeof o[m]==='function'){ try{ const v=o[m].apply(o,r); return v===undefined?null:v; }catch(e){ return null; } }
|
||||
return null;
|
||||
});
|
||||
K.registerNative('host-call-fn', a => {
|
||||
const [fn,argList]=a;
|
||||
if(!fn) return null;
|
||||
const args=(argList&&argList._type==='list'&&argList.items)?Array.from(argList.items):(Array.isArray(argList)?argList:[]);
|
||||
if(fn&&fn.__sx_handle!==undefined) return K.callFn(fn,args);
|
||||
try{ return fn.apply(null,args); }catch(e){ return null; }
|
||||
});
|
||||
K.registerNative('host-new', a => { const C=typeof a[0]==='string'?globalThis[a[0]]:a[0]; return typeof C==='function'?new C(...a.slice(1)):null; });
|
||||
K.registerNative('host-callback',a => {
|
||||
const fn=a[0];
|
||||
if(fn&&fn.__sx_handle!==undefined) return function(){ const r=K.callFn(fn,Array.from(arguments)); if(globalThis._driveAsync) globalThis._driveAsync(r); return r; };
|
||||
return typeof fn==='function'?fn:function(){};
|
||||
});
|
||||
K.registerNative('host-typeof', a => { const o=a[0]; if(o==null) return 'nil'; if(o instanceof El) return 'element'; if(o instanceof Ev) return 'event'; return typeof o; });
|
||||
K.registerNative('host-iter?', ([obj]) => obj!=null && typeof obj[Symbol.iterator]==='function');
|
||||
K.registerNative('host-to-list', ([obj]) => { try{ return [...obj]; }catch(e){ return []; } });
|
||||
K.registerNative('host-await', () => {});
|
||||
K.registerNative('host-new-function', a => { const p=(a[0]&&a[0]._type==='list')?Array.from(a[0].items):[]; try{ return new Function(...p,a[1]); }catch(e){ return null; } });
|
||||
K.registerNative('host-promise-state', a => { const p=a[0]; if(!p||typeof p.then!=='function') return null; const s=globalThis._promiseStates&&globalThis._promiseStates.get(p); return s?{ok:s.ok,value:s.value}:null; });
|
||||
K.registerNative('load-library!', () => false);
|
||||
|
||||
// Async IO driver
|
||||
let _evalDeadline = 0;
|
||||
globalThis._driveAsync = function driveAsync(r, depth) {
|
||||
depth = depth||0;
|
||||
if (_evalDeadline && Date.now() > _evalDeadline) throw new Error('TIMEOUT: wall clock exceeded');
|
||||
if (!r || !r.suspended || depth > 200) return;
|
||||
const req = r.request;
|
||||
const items = req && (req.items || req);
|
||||
const op = items && items[0];
|
||||
const opName = typeof op==='string' ? op : (op&&op.name)||String(op);
|
||||
function doResume(v) { try{ const x=r.resume(v); driveAsync(x,depth+1); }catch(e){} }
|
||||
if (opName==='io-sleep'||opName==='wait') doResume(null);
|
||||
else if (opName==='io-wait-event') {
|
||||
const target=items&&items[1];
|
||||
const evName=typeof items[2]==='string'?items[2]:'';
|
||||
const timeout=items&&items.length>3?items[3]:undefined;
|
||||
if (typeof timeout==='number') { doResume(null); }
|
||||
else if (target && target instanceof El && evName) {
|
||||
const handler=function(ev){ target.removeEventListener(evName,handler); doResume(ev); };
|
||||
target.addEventListener(evName,handler);
|
||||
} else { doResume(null); }
|
||||
}
|
||||
else if (opName==='io-transition') doResume(null);
|
||||
else doResume(null);
|
||||
};
|
||||
|
||||
// ── SX aliases ──────────────────────────────────────────────────
|
||||
K.eval('(define SX_VERSION "hs-eval-1.0")');
|
||||
K.eval('(define SX_ENGINE "ocaml-vm-sandbox")');
|
||||
K.eval('(define parse sx-parse)');
|
||||
K.eval('(define serialize sx-serialize)');
|
||||
|
||||
// ── Load HS modules ─────────────────────────────────────────────
|
||||
const WEB = ['render','core-signals','signals','deps','router','page-helpers','freeze','dom','browser',
|
||||
'adapter-html','adapter-sx','adapter-dom','boot-helpers','hypersx','engine','orchestration','boot'];
|
||||
const HS = ['hs-tokenizer','hs-parser','hs-compiler','hs-runtime','hs-integration'];
|
||||
K.beginModuleLoad();
|
||||
for (const mod of [...WEB, ...HS]) {
|
||||
const sp = path.join(SX_DIR, mod+'.sx');
|
||||
const lp = path.join(PROJECT, 'lib/hyperscript', mod.replace(/^hs-/,'')+'.sx');
|
||||
let s;
|
||||
try {
|
||||
const lpExists = mod.startsWith('hs-') && fs.existsSync(lp);
|
||||
s = lpExists ? fs.readFileSync(lp,'utf8')
|
||||
: fs.existsSync(sp) ? fs.readFileSync(sp,'utf8')
|
||||
: fs.readFileSync(lp,'utf8');
|
||||
} catch(e) { continue; }
|
||||
try { K.load(s); } catch(e) { process.stderr.write(`LOAD ERROR: ${mod}: ${e.message}\n`); }
|
||||
}
|
||||
K.endModuleLoad();
|
||||
|
||||
// ── Extra files ─────────────────────────────────────────────────
|
||||
const extraFiles = (process.env.HS_EVAL_FILES || '').split(',').filter(Boolean);
|
||||
for (const f of extraFiles) {
|
||||
try { K.load(fs.readFileSync(f.trim(),'utf8')); }
|
||||
catch(e) { process.stderr.write(`FILE ERROR: ${f}: ${e.message}\n`); }
|
||||
}
|
||||
|
||||
// ── Setup expression ────────────────────────────────────────────
|
||||
const setup = process.env.HS_EVAL_SETUP || '';
|
||||
if (setup) {
|
||||
try { K.eval(setup); }
|
||||
catch(e) {
|
||||
process.stdout.write(JSON.stringify({ok:false,error:`Setup error: ${e.message||String(e)}`})+'\n');
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
// ── Main evaluation ─────────────────────────────────────────────
|
||||
const mode = process.env.HS_EVAL_MODE || 'eval';
|
||||
const rawExpr = process.env.HS_EVAL_EXPR || process.argv[2] || '';
|
||||
if (!rawExpr) {
|
||||
process.stdout.write(JSON.stringify({ok:false,error:'No expression provided. Set HS_EVAL_EXPR or pass as first argument.'})+'\n');
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
const expr = mode==='compile' ? `(str (hs-compile ${JSON.stringify(rawExpr)}))`
|
||||
: mode==='parse' ? `(str (hs-parse ${JSON.stringify(rawExpr)}))`
|
||||
: rawExpr;
|
||||
|
||||
_evalDeadline = Date.now() + parseInt(process.env.HS_EVAL_TIMEOUT_MS||'30000');
|
||||
try {
|
||||
const result = K.eval(expr);
|
||||
let resultStr;
|
||||
try { resultStr = JSON.stringify(result); } catch(e) { resultStr = String(result); }
|
||||
process.stdout.write(JSON.stringify({ok:true,result:resultStr})+'\n');
|
||||
} catch(e) {
|
||||
process.stdout.write(JSON.stringify({ok:false,error:e.message||String(e)})+'\n');
|
||||
}
|
||||
@@ -81,7 +81,7 @@ class El {
|
||||
hasAttribute(n) { return n in this.attributes; }
|
||||
addEventListener(e,f) { if(!this._listeners[e])this._listeners[e]=[]; this._listeners[e].push(f); }
|
||||
removeEventListener(e,f) { if(this._listeners[e])this._listeners[e]=this._listeners[e].filter(x=>x!==f); }
|
||||
dispatchEvent(ev) { ev.target=ev.target||this; ev.currentTarget=this; const fns=[...(this._listeners[ev.type]||[])]; for(const f of fns){if(ev._si)break;try{f.call(this,ev);}catch(e){}} if(ev.bubbles&&!ev._sp){if(this.parentElement){this.parentElement.dispatchEvent(ev);}else if(globalThis._windowListeners){globalThis.dispatchEvent(ev);}} return !ev.defaultPrevented; }
|
||||
dispatchEvent(ev) { ev.target=ev.target||this; ev.currentTarget=this; const fns=[...(this._listeners[ev.type]||[])]; for(const f of fns){if(ev._si)break;try{f.call(this,ev);}catch(e){}} if(ev.bubbles&&!ev._sp&&this.parentElement){this.parentElement.dispatchEvent(ev);} return !ev.defaultPrevented; }
|
||||
appendChild(c) { if(c.parentElement)c.parentElement.removeChild(c); c.parentElement=this; c.parentNode=this; this.children.push(c); this.childNodes.push(c); if(this.tagName==='SELECT'&&c.tagName==='OPTION'){this.options.push(c);if(c.selected&&this.selectedIndex<0)this.selectedIndex=this.options.length-1;} this._syncText(); return c; }
|
||||
removeChild(c) { this.children=this.children.filter(x=>x!==c); this.childNodes=this.childNodes.filter(x=>x!==c); c.parentElement=null; c.parentNode=null; this._syncText(); return c; }
|
||||
insertBefore(n,r) { if(n.parentElement)n.parentElement.removeChild(n); const i=this.children.indexOf(r); if(i>=0){this.children.splice(i,0,n);this.childNodes.splice(i,0,n);}else{this.children.push(n);this.childNodes.push(n);} n.parentElement=this;n.parentNode=this; this._syncText(); return n; }
|
||||
@@ -239,9 +239,9 @@ function parseHTMLFragments(html) {
|
||||
// this keeps behaviour lenient without running past the next tag.
|
||||
}
|
||||
const el = new El(tag);
|
||||
const attrRe = /([\w-]+)(?:=(?:"([^"]*)"|'([^']*)'|([^\s>"'\/>][^\s>]*)))?/g; let am;
|
||||
const attrRe = /([\w-]+)(?:="([^"]*)")?/g; let am;
|
||||
while ((am = attrRe.exec(attrs))) {
|
||||
const nm = am[1]; const val = am[2] !== undefined ? am[2] : am[3] !== undefined ? am[3] : am[4];
|
||||
const nm = am[1]; const val = am[2];
|
||||
if (val !== undefined) el.setAttribute(nm, val);
|
||||
else el.setAttribute(nm, '');
|
||||
}
|
||||
@@ -297,15 +297,6 @@ function mt(e,s) {
|
||||
const m = base.match(/^\[([^\]=]+)(?:="([^"]*)")?\]$/);
|
||||
if(m) return m[2] !== undefined ? e.getAttribute(m[1]) === m[2] : e.hasAttribute(m[1]);
|
||||
}
|
||||
// Compound tag[attr=val] e.g. input[type=checkbox] or input[type="checkbox"]
|
||||
if(base.includes('[')) {
|
||||
const cm = base.match(/^([\w-]+)(\[.+\])$/);
|
||||
if(cm) {
|
||||
if(e.tagName.toLowerCase() !== cm[1]) return false;
|
||||
const attrParts = cm[2].match(/^\[([^\]=]+)(?:=["']?([^"'\]]+)["']?)?\]$/);
|
||||
if(attrParts) return attrParts[2] !== undefined ? e.getAttribute(attrParts[1]) === attrParts[2] : e.hasAttribute(attrParts[1]);
|
||||
}
|
||||
}
|
||||
if(base.includes('.')) { const [tag, cls] = base.split('.'); return e.tagName.toLowerCase() === tag && e.classList.contains(cls); }
|
||||
if(base.includes('#')) { const [tag, id] = base.split('#'); return e.tagName.toLowerCase() === tag && e.id === id; }
|
||||
return e.tagName.toLowerCase() === base.toLowerCase();
|
||||
@@ -336,47 +327,6 @@ const document = {
|
||||
createEvent(t){return new Ev(t);}, addEventListener(){}, removeEventListener(){},
|
||||
};
|
||||
globalThis.document=document; globalThis.window=globalThis; globalThis.HTMLElement=El; globalThis.Element=El;
|
||||
// window event-target shim (for hyperscript:beforeFetch and similar bubbled events)
|
||||
globalThis._windowListeners={};
|
||||
globalThis.addEventListener=function(e,f){if(!globalThis._windowListeners[e])globalThis._windowListeners[e]=[];globalThis._windowListeners[e].push(f);};
|
||||
globalThis.removeEventListener=function(e,f){if(globalThis._windowListeners[e])globalThis._windowListeners[e]=globalThis._windowListeners[e].filter(x=>x!==f);};
|
||||
globalThis.dispatchEvent=function(ev){const fns=[...(globalThis._windowListeners[ev.type]||[])];for(const f of fns){if(ev&&ev._si)break;try{f.call(globalThis,ev);}catch(e){}}return ev?!ev.defaultPrevented:true;};
|
||||
// cluster-33: cookie store + document.cookie + cookies Proxy.
|
||||
globalThis.__hsCookieStore = new Map();
|
||||
Object.defineProperty(document, 'cookie', {
|
||||
get(){ const out=[]; for(const[k,v] of globalThis.__hsCookieStore) out.push(k+'='+v); return out.join('; '); },
|
||||
set(s){
|
||||
const str=String(s||'');
|
||||
const m=str.match(/^\s*([^=]+?)\s*=\s*([^;]*)/);
|
||||
if(!m) return;
|
||||
const name=m[1].trim();
|
||||
const val=m[2];
|
||||
if(/expires=Thu,?\s*01\s*Jan\s*1970/i.test(str) || val==='') globalThis.__hsCookieStore.delete(name);
|
||||
else globalThis.__hsCookieStore.set(name, val);
|
||||
},
|
||||
configurable: true,
|
||||
});
|
||||
globalThis.cookies = new Proxy({}, {
|
||||
get(_, k){
|
||||
if(k==='length') return globalThis.__hsCookieStore.size;
|
||||
if(k==='clear') return (name)=>globalThis.__hsCookieStore.delete(String(name));
|
||||
if(k===Symbol.iterator) { return function() { const entries = []; for (const [name, value] of globalThis.__hsCookieStore) entries.push({_type:'dict', name, value}); return entries[Symbol.iterator](); }; }
|
||||
if(typeof k==='symbol' || k==='_order') return undefined;
|
||||
return globalThis.__hsCookieStore.has(k) ? globalThis.__hsCookieStore.get(k) : null;
|
||||
},
|
||||
set(_, k, v){ globalThis.__hsCookieStore.set(String(k), String(v)); return true; },
|
||||
has(_, k){ return globalThis.__hsCookieStore.has(k); },
|
||||
ownKeys(){ return Array.from(globalThis.__hsCookieStore.keys()); },
|
||||
getOwnPropertyDescriptor(_, k){
|
||||
if(globalThis.__hsCookieStore.has(k)) return {value: globalThis.__hsCookieStore.get(k), enumerable: true, configurable: true};
|
||||
return undefined;
|
||||
},
|
||||
[Symbol.iterator]() {
|
||||
const entries = [];
|
||||
for (const [name, value] of globalThis.__hsCookieStore) entries.push({_type:'dict', name, value});
|
||||
return entries[Symbol.iterator]();
|
||||
},
|
||||
});
|
||||
// cluster-28: test-name-keyed confirm/prompt/alert mocks. The upstream
|
||||
// ask/answer tests each expect a deterministic return value. Keyed on
|
||||
// globalThis.__currentHsTestName which the test loop sets before each test.
|
||||
@@ -395,122 +345,7 @@ globalThis.prompt = function(_msg){
|
||||
};
|
||||
globalThis.Event=Ev; globalThis.CustomEvent=Ev; globalThis.NodeList=Array; globalThis.HTMLCollection=Array;
|
||||
globalThis.getComputedStyle=(e)=>e?e.style:{}; globalThis.requestAnimationFrame=(f)=>{f();return 0;};
|
||||
globalThis.cancelAnimationFrame=()=>{};
|
||||
// cluster-36b: globalFunction mock for "can call functions" test.
|
||||
// The test calls globalFunction("foo") via hyperscript and checks window.calledWith.
|
||||
globalThis.globalFunction = function(x) { globalThis.calledWith = x; };
|
||||
// asyncCheck: async-when test needs a truthy-returning global (simulates async guard).
|
||||
globalThis.asyncCheck = function() { return true; };
|
||||
// cluster-asyncError: function that returns a rejected promise.
|
||||
globalThis.failAsync = function() { return Promise.reject(new Error("boom")); };
|
||||
// HsMutationObserver — cluster-32 mutation mock. Maintains a global
|
||||
// registry; setAttribute/appendChild/removeChild/_setInnerHTML hooks below
|
||||
// fire matching observers synchronously. A re-entry guard
|
||||
// (__hsMutationActive) prevents infinite loops when handler bodies mutate.
|
||||
globalThis.__hsMutationRegistry = [];
|
||||
globalThis.__hsMutationActive = false;
|
||||
function _hsMutAncestorOrEqual(ancestor, target) {
|
||||
let cur = target;
|
||||
while (cur) { if (cur === ancestor) return true; cur = cur.parentElement; }
|
||||
return false;
|
||||
}
|
||||
function _hsMutMatches(reg, rec) {
|
||||
const o = reg.opts;
|
||||
if (!_hsMutAncestorOrEqual(reg.target, rec.target)) return false;
|
||||
if (rec.type === 'attributes') {
|
||||
if (!o.attributes) return false;
|
||||
if (o.attributeFilter && o.attributeFilter.length > 0) {
|
||||
if (!o.attributeFilter.includes(rec.attributeName)) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (rec.type === 'childList') return !!o.childList;
|
||||
if (rec.type === 'characterData') return !!o.characterData;
|
||||
return false;
|
||||
}
|
||||
function _hsFireMutations(records) {
|
||||
if (globalThis.__hsMutationActive) return;
|
||||
if (!records || records.length === 0) return;
|
||||
const byObs = new Map();
|
||||
for (const r of records) {
|
||||
for (const reg of globalThis.__hsMutationRegistry) {
|
||||
if (!_hsMutMatches(reg, r)) continue;
|
||||
if (!byObs.has(reg.observer)) byObs.set(reg.observer, []);
|
||||
byObs.get(reg.observer).push(r);
|
||||
}
|
||||
}
|
||||
if (byObs.size === 0) return;
|
||||
globalThis.__hsMutationActive = true;
|
||||
try {
|
||||
for (const [obs, recs] of byObs) {
|
||||
try { obs._cb(recs, obs); } catch (e) {}
|
||||
}
|
||||
} finally {
|
||||
globalThis.__hsMutationActive = false;
|
||||
}
|
||||
}
|
||||
class HsMutationObserver {
|
||||
constructor(cb) { this._cb = cb; this._regs = []; }
|
||||
observe(el, opts) {
|
||||
if (!el) return;
|
||||
// opts is an SX dict: read fields directly. attributeFilter is an SX list
|
||||
// ({_type:'list', items:[...]}) OR a JS array.
|
||||
let af = opts && opts.attributeFilter;
|
||||
if (af && af._type === 'list') af = af.items;
|
||||
const o = {
|
||||
attributes: !!(opts && opts.attributes),
|
||||
childList: !!(opts && opts.childList),
|
||||
characterData: !!(opts && opts.characterData),
|
||||
subtree: !!(opts && opts.subtree),
|
||||
attributeFilter: af || null,
|
||||
};
|
||||
const reg = { observer: this, target: el, opts: o };
|
||||
this._regs.push(reg);
|
||||
globalThis.__hsMutationRegistry.push(reg);
|
||||
}
|
||||
disconnect() {
|
||||
for (const r of this._regs) {
|
||||
const i = globalThis.__hsMutationRegistry.indexOf(r);
|
||||
if (i >= 0) globalThis.__hsMutationRegistry.splice(i, 1);
|
||||
}
|
||||
this._regs = [];
|
||||
}
|
||||
takeRecords() { return []; }
|
||||
}
|
||||
globalThis.MutationObserver = HsMutationObserver;
|
||||
// Hook El prototype methods so mutations fire registered observers.
|
||||
// Hooks are no-ops while __hsMutationActive=true (prevents re-entry from
|
||||
// handler bodies that themselves mutate the DOM).
|
||||
(function _hookElForMutations() {
|
||||
const _setAttr = El.prototype.setAttribute;
|
||||
El.prototype.setAttribute = function(n, v) {
|
||||
const r = _setAttr.call(this, n, v);
|
||||
if (globalThis.__hsMutationRegistry.length)
|
||||
_hsFireMutations([{ type: 'attributes', target: this, attributeName: String(n), oldValue: null }]);
|
||||
return r;
|
||||
};
|
||||
const _append = El.prototype.appendChild;
|
||||
El.prototype.appendChild = function(c) {
|
||||
const r = _append.call(this, c);
|
||||
if (globalThis.__hsMutationRegistry.length)
|
||||
_hsFireMutations([{ type: 'childList', target: this, addedNodes: [c], removedNodes: [] }]);
|
||||
return r;
|
||||
};
|
||||
const _remove = El.prototype.removeChild;
|
||||
El.prototype.removeChild = function(c) {
|
||||
const r = _remove.call(this, c);
|
||||
if (globalThis.__hsMutationRegistry.length)
|
||||
_hsFireMutations([{ type: 'childList', target: this, addedNodes: [], removedNodes: [c] }]);
|
||||
return r;
|
||||
};
|
||||
const _setIH = El.prototype._setInnerHTML;
|
||||
El.prototype._setInnerHTML = function(html) {
|
||||
const r = _setIH.call(this, html);
|
||||
if (globalThis.__hsMutationRegistry.length)
|
||||
_hsFireMutations([{ type: 'childList', target: this, addedNodes: [], removedNodes: [] }]);
|
||||
return r;
|
||||
};
|
||||
})();
|
||||
globalThis.cancelAnimationFrame=()=>{}; globalThis.MutationObserver=class{observe(){}disconnect(){}};
|
||||
// HsResizeObserver — cluster-26 resize mock. Keeps a per-element callback
|
||||
// registry so code that observes via `new ResizeObserver(cb)` still works,
|
||||
// but HS's `on resize` uses the plain `resize` DOM event dispatched by the
|
||||
@@ -555,84 +390,7 @@ class HsIntersectionObserver {
|
||||
}
|
||||
globalThis.IntersectionObserver = HsIntersectionObserver;
|
||||
globalThis.IntersectionObserverEntry = class {};
|
||||
// WebSocket mock for socket feature tests (E36)
|
||||
globalThis.WebSocket = function HsWebSocket(url) {
|
||||
const sock = {
|
||||
url, readyState: 1, onmessage: null, onclose: null, onerror: null, onopen: null,
|
||||
_listeners: {}, _sent: [],
|
||||
send(msg) { sock._sent.push(msg); },
|
||||
addEventListener(t, h) { (sock._listeners[t] = sock._listeners[t] || []).push(h); },
|
||||
removeEventListener(t, h) { if (sock._listeners[t]) sock._listeners[t] = sock._listeners[t].filter(x => x !== h); },
|
||||
close() { sock.readyState = 3; (sock._listeners['close'] || []).forEach(h => h({})); if (sock.onclose) sock.onclose({}); }
|
||||
};
|
||||
globalThis.__hs_ws_created = globalThis.__hs_ws_created || [];
|
||||
globalThis.__hs_ws_created.push(sock);
|
||||
return sock;
|
||||
};
|
||||
globalThis.WebSocket.CONNECTING = 0; globalThis.WebSocket.OPEN = 1; globalThis.WebSocket.CLOSING = 2; globalThis.WebSocket.CLOSED = 3;
|
||||
var _iidCounter = 0;
|
||||
function _hsRpcCall(wrapper, fnName, args, timeout) {
|
||||
if (wrapper._closed) {
|
||||
const ws2 = new (wrapper._WS || globalThis.WebSocket)(wrapper._url);
|
||||
wrapper._ws = ws2; wrapper._closed = false;
|
||||
if (wrapper._onmessage_handler) ws2.onmessage = wrapper._onmessage_handler;
|
||||
ws2.addEventListener('close', () => { wrapper._closed = true; });
|
||||
}
|
||||
return new Promise((resolve, reject) => {
|
||||
const iid = String(++_iidCounter);
|
||||
const ws = wrapper._ws;
|
||||
if (!wrapper._pending) wrapper._pending = {};
|
||||
wrapper._pending[iid] = { resolve, reject };
|
||||
if (ws && ws.send) ws.send(JSON.stringify({ iid, function: fnName, args }));
|
||||
if (timeout !== Infinity && timeout != null) {
|
||||
setTimeout(() => {
|
||||
if (wrapper._pending && wrapper._pending[iid]) {
|
||||
delete wrapper._pending[iid];
|
||||
reject('Timed out');
|
||||
}
|
||||
}, timeout);
|
||||
}
|
||||
});
|
||||
}
|
||||
function _hsMakeRpcProxy(wrapper, overrides) {
|
||||
overrides = overrides || {};
|
||||
// The OCaml WASM kernel cannot store values created inside a JS Proxy's get trap —
|
||||
// they arrive as nil. Use a dispatch-object pattern instead: host-get detects
|
||||
// _hsRpcDispatch and calls it directly, bypassing Proxy trap issues.
|
||||
const rpc = function() {};
|
||||
rpc._hsRpcDispatch = function(name) {
|
||||
name = String(name);
|
||||
if (['then', 'catch', 'length', 'toJSON'].includes(name)) return null;
|
||||
if (name === 'noTimeout') return _hsMakeRpcProxy(wrapper, Object.assign({}, overrides, { timeout: Infinity }));
|
||||
if (name === 'timeout') return function(n) { return _hsMakeRpcProxy(wrapper, Object.assign({}, overrides, { timeout: n })); };
|
||||
const t = overrides.timeout !== undefined ? overrides.timeout : (wrapper._timeout != null ? wrapper._timeout : 0);
|
||||
return function() { return _hsRpcCall(wrapper, name, Array.from(arguments), t); };
|
||||
};
|
||||
return rpc;
|
||||
}
|
||||
globalThis._hs_make_rpc_proxy = _hsMakeRpcProxy;
|
||||
function _hsSetupSocket(wrapper) {
|
||||
wrapper.dispatchEvent = function(evt) {
|
||||
if (wrapper._closed) {
|
||||
const ws2 = new (wrapper._WS || globalThis.WebSocket)(wrapper._url);
|
||||
wrapper._ws = ws2; wrapper._closed = false;
|
||||
if (wrapper._onmessage_handler) ws2.onmessage = wrapper._onmessage_handler;
|
||||
ws2.addEventListener('close', () => { wrapper._closed = true; });
|
||||
}
|
||||
const ws = wrapper._ws;
|
||||
if (!ws) return;
|
||||
const payload = { type: evt.type };
|
||||
const detail = evt.detail || {};
|
||||
for (const k of Object.keys(detail)) {
|
||||
if (k !== 'sender' && k !== '_namedArgList_' && k !== '_type') payload[k] = detail[k];
|
||||
}
|
||||
ws.send(JSON.stringify(payload));
|
||||
};
|
||||
wrapper.rpc = _hsMakeRpcProxy(wrapper, {});
|
||||
return wrapper;
|
||||
}
|
||||
globalThis._hsSetupSocket = _hsSetupSocket;
|
||||
globalThis.navigator={userAgent:'node'}; globalThis.location={href:'http://localhost/',pathname:'/',search:'',hash:'',protocol:'http:',host:'localhost',hostname:'localhost',port:''};
|
||||
globalThis.navigator={userAgent:'node'}; globalThis.location={href:'http://localhost/',pathname:'/',search:'',hash:''};
|
||||
globalThis.history={pushState(){},replaceState(){},back(){},forward(){}};
|
||||
globalThis.getSelection=()=>({toString:()=>(globalThis.__test_selection||'')});
|
||||
const _origLog = console.log;
|
||||
@@ -640,9 +398,6 @@ globalThis.console = { log: () => {}, error: () => {}, warn: () => {}, info: ()
|
||||
const _log = _origLog; // keep reference for our own output
|
||||
|
||||
// ─── FFI ────────────────────────────────────────────────────────
|
||||
// JS-level reference equality for host objects (works around OCaml boxing).
|
||||
// The SX `=` primitive doesn't do JS === for host objects in the WASM kernel.
|
||||
K.registerNative('hs-ref-eq',a=>a[0]===a[1]);
|
||||
K.registerNative('host-global',a=>{const n=a[0];return(n in globalThis)?globalThis[n]:null;});
|
||||
K.registerNative('host-get',a=>{
|
||||
if(a[0]==null)return null;
|
||||
@@ -650,87 +405,21 @@ K.registerNative('host-get',a=>{
|
||||
// through JS property access. Hand-roll common collection queries so
|
||||
// compiled HS `x.length` / `x.size` works on scoped lists.
|
||||
if(a[0] && a[0]._type==='list' && (a[1]==='length' || a[1]==='size')) return a[0].items.length;
|
||||
if(a[0] && a[0]._type==='list' && typeof a[1]==='number') return a[0].items[a[1]]!==undefined?a[0].items[a[1]]:null;
|
||||
if(a[0] && a[0]._type==='dict' && a[1]==='size') return Object.keys(a[0]).filter(k=>k!=='_type').length;
|
||||
// innerText is DOM-level alias for textContent (close enough for mock purposes)
|
||||
if(a[0] instanceof El && a[1]==='innerText') return String(a[0].textContent||'');
|
||||
// RPC dispatch object: _hsRpcDispatch bypasses Proxy-in-WASM-kernel nil issue
|
||||
if(a[0] && typeof a[0]._hsRpcDispatch==='function'){const rv=a[0]._hsRpcDispatch(String(a[1]));return rv===undefined?null:rv;}
|
||||
let v=a[0][a[1]];
|
||||
if(v===undefined)return null;
|
||||
// Only coerce DOM property strings for actual DOM elements — plain JS objects
|
||||
// (e.g. promise-state dicts with a "value" key) must not be stringified.
|
||||
if(a[0] instanceof El&&(a[1]==='innerHTML'||a[1]==='textContent'||a[1]==='value'||a[1]==='className')&&typeof v!=='string')v=String(v!=null?v:'');
|
||||
if((a[1]==='innerHTML'||a[1]==='textContent'||a[1]==='value'||a[1]==='className')&&typeof v!=='string')v=String(v!=null?v:'');
|
||||
return v;
|
||||
});
|
||||
K.registerNative('host-set!',a=>{if(a[0]!=null){const v=a[2]; if(a[1]==='innerHTML'&&a[0] instanceof El){const s=v===null?'null':v===undefined?'':String(v);a[0]._setInnerHTML(s);a[0][a[1]]=a[0].innerHTML;} else if(a[1]==='textContent'&&a[0] instanceof El){const s=v===null?'null':v===undefined?'':String(v);a[0].textContent=s;a[0].innerHTML=s;for(const c of a[0].children){c.parentElement=null;c.parentNode=null;}a[0].children=[];a[0].childNodes=[];} else{a[0][a[1]]=v;}} return a[2];});
|
||||
K.registerNative('host-call',a=>{if(_testDeadline&&Date.now()>_testDeadline)throw new Error('TIMEOUT: wall clock exceeded');const[o,m,...r]=a;if(o==null){const f=globalThis[m];return typeof f==='function'?f.apply(null,r):null;}if(o&&typeof o[m]==='function'){try{const v=o[m].apply(o,r);return v===undefined?null:v;}catch(e){return null;}}return null;});
|
||||
K.registerNative('host-call-fn',a=>{const[fn,argList]=a;if(typeof fn!=='function'&&!(fn&&fn.__sx_handle!==undefined))return null;const callArgs=(argList&&argList._type==='list'&&argList.items)?Array.from(argList.items):(Array.isArray(argList)?argList:[]);if(fn&&fn.__sx_handle!==undefined){try{return K.callFn(fn,callArgs);}catch(e){const msg=e&&e.message||'';if(String(msg).includes('TIMEOUT'))throw e;return null;}}function sxToJs(v){if(v&&v._type==='list'&&v.items)return Array.from(v.items).map(sxToJs);return v;}try{const v=fn.apply(null,callArgs.map(sxToJs));return v===undefined?null:v;}catch(e){return null;}});
|
||||
K.registerNative('host-new',a=>{const C=typeof a[0]==='string'?globalThis[a[0]]:a[0];return typeof C==='function'?new C(...a.slice(1)):null;});
|
||||
K.registerNative('host-callback',a=>{const fn=a[0];if(typeof fn==='function'&&fn.__sx_handle===undefined)return fn;if(fn&&fn.__sx_handle!==undefined)return function(){const r=K.callFn(fn,Array.from(arguments));if(globalThis._driveAsync)globalThis._driveAsync(r);return r;};return function(){};});
|
||||
K.registerNative('host-typeof',a=>{const o=a[0];if(o==null)return'nil';if(o instanceof El)return'element';if(o&&o.nodeType===3)return'text';if(o instanceof Ev)return'event';if(o instanceof Promise)return'promise';return typeof o;});
|
||||
K.registerNative('host-iter?',([obj])=>obj!=null&&typeof obj[Symbol.iterator]==='function');
|
||||
K.registerNative('host-to-list',([obj])=>{try{return[...obj];}catch(e){return[];}});
|
||||
K.registerNative('host-await',a=>{});
|
||||
K.registerNative('load-library!',()=>false);
|
||||
K.registerNative('hs-is-set?',a=>a[0] instanceof Set);
|
||||
K.registerNative('hs-is-map?',a=>a[0] instanceof Map);
|
||||
// Upstream test fixtures: synchronous stubs matching OCaml run_tests.ml registrations
|
||||
globalThis.promiseAString = () => 'foo';
|
||||
globalThis.promiseAnInt = () => 42;
|
||||
|
||||
// ── JS block execution support ─────────────────────────────────
|
||||
// Track promise states for synchronous introspection in hs-js-exec
|
||||
const _promiseStates = new WeakMap();
|
||||
const _origPReject = Promise.reject.bind(Promise);
|
||||
const _origPResolve = Promise.resolve.bind(Promise);
|
||||
Promise.reject = function(v) {
|
||||
const p = _origPReject(v);
|
||||
_promiseStates.set(p, {ok: false, value: v});
|
||||
p.catch(() => {}); // suppress unhandled rejection warning
|
||||
return p;
|
||||
};
|
||||
Promise.resolve = function(v) {
|
||||
if (v && typeof v === 'object' && typeof v.then === 'function') return _origPResolve(v);
|
||||
const p = _origPResolve(v);
|
||||
_promiseStates.set(p, {ok: true, value: v});
|
||||
return p;
|
||||
};
|
||||
|
||||
K.registerNative('host-new-function', a => {
|
||||
const paramList = a[0];
|
||||
const src = a[1];
|
||||
const params = paramList && paramList._type === 'list' && paramList.items
|
||||
? Array.from(paramList.items)
|
||||
: Array.isArray(paramList) ? paramList : [];
|
||||
try { return new Function(...params, src); } catch(e) { return null; }
|
||||
});
|
||||
|
||||
K.registerNative('host-promise-state', a => {
|
||||
const p = a[0];
|
||||
if (!p || typeof p.then !== 'function') return null;
|
||||
const s = _promiseStates.get(p);
|
||||
if (!s) return null;
|
||||
// Wrap Error objects as plain dicts — the WASM bridge serializes arbitrary
|
||||
// JS objects to strings, so we extract message before crossing the boundary.
|
||||
const val = s.value instanceof Error
|
||||
? {message: s.value.message}
|
||||
: (s.value != null ? s.value : null);
|
||||
return {ok: s.ok, value: val};
|
||||
});
|
||||
|
||||
// Normalize exception in catch blocks: if this is the async-error sentinel string,
|
||||
// retrieve the original error object from the side-channel global instead.
|
||||
K.registerNative('host-hs-normalize-exc', a => {
|
||||
const val = a[0];
|
||||
const pending = globalThis.__hs_async_error;
|
||||
if (pending !== undefined && pending !== null && val === '__hs_async_error__') {
|
||||
globalThis.__hs_async_error = null;
|
||||
return pending;
|
||||
}
|
||||
globalThis.__hs_async_error = null;
|
||||
return val;
|
||||
});
|
||||
|
||||
let _testDeadline = 0;
|
||||
// Mock fetch routes
|
||||
@@ -741,41 +430,23 @@ const _fetchRoutes = {
|
||||
'/number': { status: 200, body: '1.2' },
|
||||
'/users/Joe': { status: 200, body: 'Joe', json: '{"name":"Joe"}' },
|
||||
};
|
||||
// Per-test fetch overrides keyed by test name; takes priority over _fetchRoutes.
|
||||
const _fetchScripts = {
|
||||
"as response does not throw on 404":
|
||||
{ "/test": { status: 404, body: "not found" } },
|
||||
"do not throw passes through 404 response":
|
||||
{ "/test": { status: 404, body: "the body" } },
|
||||
"don't throw passes through 404 response":
|
||||
{ "/test": { status: 404, body: "the body" } },
|
||||
"throws on non-2xx response by default":
|
||||
{ "/test": { status: 404, body: "not found" } },
|
||||
"Response can be converted to JSON via as JSON":
|
||||
{ "/test": { status: 200, body: '{"name":"Joe"}', json: '{"name":"Joe"}',
|
||||
contentType: "application/json" } },
|
||||
"can catch an error that occurs when using fetch":
|
||||
{ "/test": { networkError: true } },
|
||||
"triggers an event just before fetching":
|
||||
{ "/test": { status: 200, body: "yay", contentType: "text/html" } },
|
||||
"can do a simple fetch w/ a custom conversion":
|
||||
{ "/test": { status: 200, body: "1.2" } },
|
||||
};
|
||||
function _mockFetch(url) {
|
||||
const scriptRoutes = _fetchScripts[globalThis.__currentHsTestName];
|
||||
const route = (scriptRoutes && scriptRoutes[url]) || _fetchRoutes[url] || _fetchRoutes['/test'];
|
||||
return { ok: (route.status||200) < 400, status: route.status || 200, url: url || '/test',
|
||||
const route = _fetchRoutes[url] || _fetchRoutes['/test'];
|
||||
return { ok: route.status < 400, status: route.status || 200, url: url || '/test',
|
||||
_body: route.body || '', _json: route.json || route.body || '', _html: route.html || route.body || '' };
|
||||
}
|
||||
globalThis._driveAsync=function driveAsync(r,d){d=d||0;if(_testDeadline && Date.now()>_testDeadline)throw new Error('TIMEOUT: wall clock exceeded');if(globalThis._hs_null_error)return;if(d>500||!r||!r.suspended)return;const req=r.request;const items=req&&(req.items||req);const op=items&&items[0];const opName=typeof op==='string'?op:(op&&op.name)||String(op);
|
||||
function doResume(v){try{const x=r.resume(v);driveAsync(x,d+1);}catch(e){const msg=e&&(e.message||(Array.isArray(e)&&typeof e[2]==='string'&&e[2])||'');if(String(msg).includes('TIMEOUT'))throw e;}}
|
||||
globalThis._driveAsync=function driveAsync(r,d){d=d||0;if(d>500||!r||!r.suspended)return;if(_testDeadline && Date.now()>_testDeadline)throw new Error('TIMEOUT: wall clock exceeded');const req=r.request;const items=req&&(req.items||req);const op=items&&items[0];const opName=typeof op==='string'?op:(op&&op.name)||String(op);
|
||||
function doResume(v){try{const x=r.resume(v);driveAsync(x,d+1);}catch(e){}}
|
||||
if(opName==='io-sleep'||opName==='wait')doResume(null);
|
||||
else if(opName==='io-fetch'){
|
||||
const url=typeof items[1]==='string'?items[1]:'/test';
|
||||
const scriptRoutes=_fetchScripts[globalThis.__currentHsTestName];
|
||||
const route=(scriptRoutes&&scriptRoutes[url])||_fetchRoutes[url]||_fetchRoutes['/test'];
|
||||
if(route&&route.networkError){doResume({_type:'dict','_network-error':true,message:'aborted'});}
|
||||
else{const st=route.status||200;doResume({_type:'dict',ok:st<400,status:st,url,_body:route.body||'',_json:route.json||route.body||'',_html:route.html||route.body||'',_number:route.number||route.body||''});}
|
||||
const fmt=typeof items[2]==='string'?items[2]:'text';
|
||||
const route=_fetchRoutes[url]||_fetchRoutes['/test'];
|
||||
if(fmt==='json'){try{doResume(JSON.parse(route.json||route.body||'{}'));}catch(e){doResume(null);}}
|
||||
else if(fmt==='html'){const frag=new El('fragment');frag.nodeType=11;frag.innerHTML=route.html||route.body||'';frag.textContent=frag.innerHTML.replace(/<[^>]*>/g,'');doResume(frag);}
|
||||
else if(fmt==='response')doResume({ok:(route.status||200)<400,status:route.status||200,url});
|
||||
else if(fmt.toLowerCase()==='number')doResume(parseFloat(route.number||route.body||'0'));
|
||||
else doResume(route.body||'');
|
||||
}
|
||||
else if(opName==='io-parse-text'){const resp=items&&items[1];doResume(resp&&resp._body?resp._body:typeof resp==='string'?resp:'');}
|
||||
else if(opName==='io-parse-json'){const resp=items&&items[1];try{doResume(JSON.parse(typeof resp==='string'?resp:resp&&resp._json?resp._json:'{}'));}catch(e){doResume(null);}}
|
||||
@@ -810,8 +481,7 @@ const t_mod = Date.now();
|
||||
const WEB=['render','core-signals','signals','deps','router','page-helpers','freeze','dom','browser','adapter-html','adapter-sx','adapter-dom','boot-helpers','hypersx','engine','orchestration','boot'];
|
||||
const HS=['hs-tokenizer','hs-parser','hs-compiler','hs-runtime','hs-integration'];
|
||||
K.beginModuleLoad();
|
||||
// hs-* modules: prefer lib/hyperscript/ (source of truth for conformance work) over WASM sx dir
|
||||
for(const mod of[...WEB,...HS]){const sp=path.join(SX_DIR,mod+'.sx');const lp=path.join(PROJECT,'lib/hyperscript',mod.replace(/^hs-/,'')+'.sx');let s;try{const lpExists=mod.startsWith('hs-')&&fs.existsSync(lp);s=lpExists?fs.readFileSync(lp,'utf8'):(fs.existsSync(sp)?fs.readFileSync(sp,'utf8'):fs.readFileSync(lp,'utf8'));}catch(e){continue;}try{K.load(s);}catch(e){process.stderr.write(`LOAD ERROR: ${mod}: ${e.message}\n`);}}
|
||||
for(const mod of[...WEB,...HS]){const sp=path.join(SX_DIR,mod+'.sx');const lp=path.join(PROJECT,'lib/hyperscript',mod.replace(/^hs-/,'')+'.sx');let s;try{s=fs.existsSync(sp)?fs.readFileSync(sp,'utf8'):fs.readFileSync(lp,'utf8');}catch(e){continue;}try{K.load(s);}catch(e){process.stderr.write(`LOAD ERROR: ${mod}: ${e.message}\n`);}}
|
||||
K.endModuleLoad();
|
||||
process.stderr.write(`Modules loaded in ${Date.now()-t_mod}ms\n`);
|
||||
|
||||
@@ -846,26 +516,6 @@ for(const f of['spec/harness.sx','spec/tests/test-framework.sx','spec/tests/test
|
||||
}
|
||||
process.stderr.write(`Tests loaded in ${Date.now()-t_tests}ms\n`);
|
||||
|
||||
// Redefine try-call to actually catch errors for assert-throws.
|
||||
// During loading it was the registration version (stores thunks, returns {:ok true}).
|
||||
// Now that tests are registered, redefine it to run the thunk and catch any exception.
|
||||
K.eval('(define try-call _run-test-thunk)');
|
||||
|
||||
// Override eval-hs-error for runtimeErrors tests: hs-null-raise!/hs-empty-raise!/hs-win-call
|
||||
// each wrap their (raise msg) in a self-contained guard so the raise is swallowed before
|
||||
// it can escape through the empty JIT kont and trigger the slow host_error path (~34s).
|
||||
// The null error message is stored in window._hs_null_error (side channel) before the raise,
|
||||
// so we can recover it here even when eval-hs returns normally.
|
||||
K.eval(`(define eval-hs-error
|
||||
(fn (src)
|
||||
(host-set! (host-global "window") "_hs_null_error" nil)
|
||||
(let ((result
|
||||
(guard (_e (true (if (string? _e) _e (str _e))))
|
||||
(eval-hs src)
|
||||
nil)))
|
||||
(or (host-get (host-global "window") "_hs_null_error") result))))`);
|
||||
K.eval('(define x nil)(define y nil)(define z nil)');
|
||||
|
||||
const testCount = K.eval('(len _test-registry)');
|
||||
// Pre-read names
|
||||
const names = [];
|
||||
@@ -889,96 +539,24 @@ for(let i=startTest;i<Math.min(endTest,testCount);i++){
|
||||
|
||||
// Reset body
|
||||
_body.children=[];_body.childNodes=[];_body.innerHTML='';_body.textContent='';
|
||||
globalThis._hs_null_error=null;
|
||||
globalThis.__test_selection='';
|
||||
globalThis.__hsCookieStore.clear();
|
||||
globalThis.__hsMutationRegistry.length = 0;
|
||||
globalThis.__hsMutationActive = false;
|
||||
globalThis._windowListeners={};
|
||||
globalThis.__currentHsTestName = name;
|
||||
|
||||
// Hypertrace tests use async wait loops that legitimately exceed the step limit.
|
||||
// Disable CEK step counting for these — wall-clock deadline still applies.
|
||||
// Tests that require async event dispatch not supported in the sync test runner.
|
||||
// These tests hang indefinitely because io-wait-event suspends the OCaml kernel
|
||||
// waiting for an event that is never fired from outside the K.eval call chain.
|
||||
const _SKIP_TESTS = new Set([
|
||||
"until event keyword works",
|
||||
// Generator gap: spec is missing click dispatches; asserts textContent="1" with no events fired.
|
||||
"throttled at <time> drops events within the window",
|
||||
]);
|
||||
if (_SKIP_TESTS.has(name)) continue;
|
||||
|
||||
const _NO_STEP_LIMIT = new Set([
|
||||
"async hypertrace is reasonable",
|
||||
"hypertrace from javascript is reasonable",
|
||||
"hypertrace is reasonable",
|
||||
"repeat forever works",
|
||||
"repeat forever works w/o keyword",
|
||||
"receives named events",
|
||||
"passes the sieve test",
|
||||
]);
|
||||
// Suites where JIT cascade legitimately exceeds the per-test step limit.
|
||||
const _NO_STEP_LIMIT_SUITES = new Set([
|
||||
"hs-upstream-core/runtimeErrors",
|
||||
"hs-upstream-expressions/collectionExpressions",
|
||||
"hs-upstream-expressions/typecheck",
|
||||
"hs-upstream-socket",
|
||||
]);
|
||||
// Enable step limit for timeout protection — reset counter first so accumulation
|
||||
// across tests doesn't cause signed-32-bit wraparound (~2B extra steps before limit fires).
|
||||
// Hypertrace tests instrument every evaluation and legitimately exceed the step limit.
|
||||
resetStepCount();
|
||||
setStepLimit((_NO_STEP_LIMIT.has(name) || _NO_STEP_LIMIT_SUITES.has(suite)) ? 0 : STEP_LIMIT);
|
||||
const _SLOW_DEADLINE = {
|
||||
"async hypertrace is reasonable": 8000,
|
||||
"hypertrace from javascript is reasonable": 8000,
|
||||
"hypertrace is reasonable": 8000,
|
||||
"passes the sieve test": 180000,
|
||||
"behavior scoping is isolated from other behaviors": 60000,
|
||||
"behavior scoping is isolated from the core element scope": 60000,
|
||||
// repeat suite: two JIT preheat calls each take 7-12s cold
|
||||
"can nest loops": 60000,
|
||||
"only executes the init expression once": 60000,
|
||||
"repeat forever works": 60000,
|
||||
"repeat forever works w/o keyword": 60000,
|
||||
"until keyword works": 60000,
|
||||
"while keyword works": 60000,
|
||||
};
|
||||
const _SLOW_DEADLINE_SUITES = {
|
||||
"hs-upstream-core/runtimeErrors": 30000,
|
||||
"hs-upstream-expressions/collectionExpressions": 60000,
|
||||
"hs-upstream-expressions/typecheck": 30000,
|
||||
"hs-upstream-behavior": 20000,
|
||||
// eventsource: JIT saturation after multiple compilations in suite sequence
|
||||
"hs-upstream-ext/eventsource": 30000,
|
||||
// socket: first call to hs-socket-register! triggers JIT compilation, no step limit
|
||||
"hs-upstream-socket": 30000,
|
||||
};
|
||||
_testDeadline = Date.now() + (_SLOW_DEADLINE[name] || _SLOW_DEADLINE_SUITES[suite] || 10000);
|
||||
globalThis.__hs_deadline = _testDeadline; // expose to WASM cek_step_loop
|
||||
// Enable step limit for timeout protection
|
||||
setStepLimit(STEP_LIMIT);
|
||||
_testDeadline = Date.now() + 10000; // 10 second wall-clock timeout per test
|
||||
if(process.env.HS_VERBOSE)process.stderr.write(`T${i} `);
|
||||
|
||||
let ok=false,err=null;
|
||||
try{
|
||||
// Use SX-level guard to catch errors, avoiding __sxR side-channel issues
|
||||
// Returns a dict with :ok and :error keys.
|
||||
// Note: api_eval returns "Error: <msg>" string (not throw) for SX exceptions,
|
||||
// so K.eval may return an error string rather than throwing. Check for this.
|
||||
const defineR = K.eval(`(define _test-result (_run-test-thunk (get (nth _test-registry ${i}) "thunk")))`);
|
||||
// Clear deadline immediately: once the test thunk finishes (or times out and
|
||||
// the guard catches it), further K.eval calls for result inspection must not
|
||||
// keep re-firing the deadline check on every 10k steps.
|
||||
globalThis.__hs_deadline = 0;
|
||||
if(typeof defineR==='string' && defineR.startsWith('Error: ')){
|
||||
err=defineR.slice(7,157); // strip "Error: " prefix
|
||||
} else {
|
||||
const isOk=K.eval('(get _test-result "ok")');
|
||||
if(isOk===true){ok=true;}
|
||||
else{
|
||||
const errMsg=K.eval('(get _test-result "error")');
|
||||
err=errMsg?String(errMsg).slice(0,150):'unknown error';
|
||||
}
|
||||
// Returns a dict with :ok and :error keys
|
||||
K.eval(`(define _test-result (_run-test-thunk (get (nth _test-registry ${i}) "thunk")))`);
|
||||
const isOk=K.eval('(get _test-result "ok")');
|
||||
if(isOk===true){ok=true;}
|
||||
else{
|
||||
const errMsg=K.eval('(get _test-result "error")');
|
||||
err=errMsg?String(errMsg).slice(0,150):'unknown error';
|
||||
}
|
||||
}catch(e){err=(e.message||'').slice(0,150);}
|
||||
setStepLimit(0); // disable step limit between tests
|
||||
@@ -996,7 +574,7 @@ for(let i=startTest;i<Math.min(endTest,testCount);i++){
|
||||
else if(err&&err.includes('Unhandled'))t='unhandled';
|
||||
errTypes[t]=(errTypes[t]||0)+1;
|
||||
}
|
||||
_testDeadline = 0; globalThis.__hs_deadline = 0;
|
||||
_testDeadline = 0;
|
||||
if((i+1)%100===0)process.stdout.write(` ${i+1}/${testCount} (${passed} pass, ${failed} fail)\n`);
|
||||
if(elapsed > 5000)process.stdout.write(` SLOW: test ${i} took ${elapsed}ms [${suite}] ${name}\n`);
|
||||
if(!ok && err && err.includes('TIMEOUT'))process.stdout.write(` TIMEOUT: test ${i} [${suite}] ${name}\n`);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -18,8 +18,7 @@ import time
|
||||
|
||||
PROJECT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
RUNNER_PATH = os.path.join(PROJECT_DIR, "tests/hs-run-filtered.js")
|
||||
GEN_PATH = os.path.join(PROJECT_DIR, "tests/playwright/generate-sx-tests.py")
|
||||
EVAL_PATH = os.path.join(PROJECT_DIR, "tests/hs-kernel-eval.js")
|
||||
GEN_PATH = os.path.join(PROJECT_DIR, "tests/playwright/generate-sx-tests.py")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
@@ -219,135 +218,6 @@ def hs_test_status(args):
|
||||
return text_result("\n".join(info))
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Shared helper: run hs-kernel-eval.js
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _kernel_eval(mode, expr, setup=None, files=None, timeout_secs=60):
|
||||
"""Run hs-kernel-eval.js and return a text_result."""
|
||||
if not os.path.isfile(EVAL_PATH):
|
||||
return error_result(f"Eval script not found at {EVAL_PATH}")
|
||||
env = os.environ.copy()
|
||||
env["HS_EVAL_MODE"] = mode
|
||||
env["HS_EVAL_EXPR"] = expr
|
||||
env["HS_EVAL_TIMEOUT_MS"] = str(max(5000, int(timeout_secs) * 1000))
|
||||
if setup:
|
||||
env["HS_EVAL_SETUP"] = setup
|
||||
if files:
|
||||
env["HS_EVAL_FILES"] = ",".join(files)
|
||||
timeout = max(10, min(int(timeout_secs), 300))
|
||||
try:
|
||||
r = subprocess.run(
|
||||
["node", EVAL_PATH],
|
||||
cwd=PROJECT_DIR, env=env,
|
||||
capture_output=True, text=True, timeout=timeout,
|
||||
)
|
||||
except subprocess.TimeoutExpired:
|
||||
return error_result(f"Kernel eval timed out after {timeout}s")
|
||||
stderr = (r.stderr or "").strip()
|
||||
stdout = (r.stdout or "").strip()
|
||||
# Parse JSON result from stdout
|
||||
try:
|
||||
import json
|
||||
data = json.loads(stdout)
|
||||
if data.get("ok"):
|
||||
result = data.get("result", "nil")
|
||||
# Unescape JSON-stringified result
|
||||
try:
|
||||
result = json.loads(result)
|
||||
except Exception:
|
||||
pass
|
||||
out = f"Result: {result}"
|
||||
else:
|
||||
out = f"Error: {data.get('error', 'unknown error')}"
|
||||
except Exception:
|
||||
out = stdout or "(no output)"
|
||||
if stderr:
|
||||
# Filter noisy load-progress lines, keep errors
|
||||
err_lines = [l for l in stderr.splitlines()
|
||||
if not l.startswith("Loading") and not l.startswith("Modules") and "ms" not in l]
|
||||
if err_lines:
|
||||
out += "\n\nstderr:\n" + "\n".join(err_lines)
|
||||
return text_result(out)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tool: sx_kernel_eval
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def sx_kernel_eval(args):
|
||||
"""Evaluate a SX expression in the full WASM kernel with HS modules loaded.
|
||||
|
||||
The kernel includes mock DOM, so HS runtime functions (hs-repeat-forever,
|
||||
hs-compile, dom-dispatch, etc.) are available. Use this when sx_harness_eval
|
||||
fails due to missing host primitives (host-new, host-get, etc.).
|
||||
|
||||
Args:
|
||||
expr: SX expression to evaluate (required).
|
||||
setup: SX setup expression run before main eval (optional).
|
||||
files: List of .sx files to load before eval (optional).
|
||||
timeout_secs: Wall-clock cap in seconds (default 60, max 300).
|
||||
"""
|
||||
expr = args.get("expr", "").strip()
|
||||
if not expr:
|
||||
return error_result("'expr' is required")
|
||||
return _kernel_eval(
|
||||
mode="eval",
|
||||
expr=expr,
|
||||
setup=args.get("setup"),
|
||||
files=args.get("files"),
|
||||
timeout_secs=int(args.get("timeout_secs", 60)),
|
||||
)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tool: hs_compile_inspect
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def hs_compile_inspect(args):
|
||||
"""Compile an HS source string and return the generated SX AST.
|
||||
|
||||
Runs hs-compile on the source and returns its string representation.
|
||||
Useful for debugging what AST the HS compiler produces for a given snippet.
|
||||
|
||||
Args:
|
||||
hs_source: HS source code to compile (required).
|
||||
timeout_secs: Wall-clock cap in seconds (default 30).
|
||||
"""
|
||||
src = args.get("hs_source", "").strip()
|
||||
if not src:
|
||||
return error_result("'hs_source' is required")
|
||||
return _kernel_eval(
|
||||
mode="compile",
|
||||
expr=src,
|
||||
timeout_secs=int(args.get("timeout_secs", 30)),
|
||||
)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tool: hs_parse_inspect
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def hs_parse_inspect(args):
|
||||
"""Parse an HS source string and return the raw parser AST (before compilation).
|
||||
|
||||
Runs hs-parse on the source and returns its string representation.
|
||||
Useful for debugging tokenizer/parser output before the compiler sees it.
|
||||
|
||||
Args:
|
||||
hs_source: HS source code to parse (required).
|
||||
timeout_secs: Wall-clock cap in seconds (default 30).
|
||||
"""
|
||||
src = args.get("hs_source", "").strip()
|
||||
if not src:
|
||||
return error_result("'hs_source' is required")
|
||||
return _kernel_eval(
|
||||
mode="parse",
|
||||
expr=src,
|
||||
timeout_secs=int(args.get("timeout_secs", 30)),
|
||||
)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# JSON-RPC dispatch
|
||||
# ---------------------------------------------------------------------------
|
||||
@@ -395,40 +265,6 @@ TOOLS = [
|
||||
{},
|
||||
[],
|
||||
),
|
||||
tool(
|
||||
"sx_kernel_eval",
|
||||
"Evaluate a SX expression in the full WASM kernel with HS modules and mock DOM loaded. "
|
||||
"Use when sx_harness_eval fails due to missing host primitives (host-new, host-get, etc.). "
|
||||
"Has access to hs-compile, hs-parse, hs-repeat-forever, dom-dispatch, etc.",
|
||||
{
|
||||
"expr": {"type": "string", "description": "SX expression to evaluate"},
|
||||
"setup": {"type": "string", "description": "SX setup expression run before eval (optional)"},
|
||||
"files": {"type": "array", "items": {"type": "string"},
|
||||
"description": "Extra .sx files to load before eval (optional)"},
|
||||
"timeout_secs": {"type": "integer", "description": "Wall-clock cap in seconds (default 60, max 300)"},
|
||||
},
|
||||
["expr"],
|
||||
),
|
||||
tool(
|
||||
"hs_compile_inspect",
|
||||
"Compile an HS source snippet and return the generated SX AST string. "
|
||||
"Runs hs-compile and returns (str result). Use to debug what AST the compiler produces.",
|
||||
{
|
||||
"hs_source": {"type": "string", "description": "HS source code to compile"},
|
||||
"timeout_secs": {"type": "integer", "description": "Wall-clock cap in seconds (default 30)"},
|
||||
},
|
||||
["hs_source"],
|
||||
),
|
||||
tool(
|
||||
"hs_parse_inspect",
|
||||
"Parse an HS source snippet and return the raw parser AST (before compilation). "
|
||||
"Runs hs-parse and returns (str result). Use to debug tokenizer/parser output.",
|
||||
{
|
||||
"hs_source": {"type": "string", "description": "HS source code to parse"},
|
||||
"timeout_secs": {"type": "integer", "description": "Wall-clock cap in seconds (default 30)"},
|
||||
},
|
||||
["hs_source"],
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
@@ -442,12 +278,6 @@ def handle_tool(name, args):
|
||||
return hs_test_regen(args)
|
||||
case "hs_test_status":
|
||||
return hs_test_status(args)
|
||||
case "sx_kernel_eval":
|
||||
return sx_kernel_eval(args)
|
||||
case "hs_compile_inspect":
|
||||
return hs_compile_inspect(args)
|
||||
case "hs_parse_inspect":
|
||||
return hs_parse_inspect(args)
|
||||
case _:
|
||||
return error_result(f"Unknown tool: {name}")
|
||||
|
||||
|
||||
Reference in New Issue
Block a user