substrate-lang 0.9.4 → 0.10.0

package/std/package/git.sub

@@ -5,30 +5,29 @@
 
 (provide git-tracked)
 
-;; git-tracked adds the paths, relative to dir, of the regular files the index lists under dir. It gives 1 when they
-;; include dir's marker file, 0 when they do not or no repository holds dir, and -1, with err set, when it cannot read
-;; the index.
-(define (git-tracked [a (ptr arena)] [dir string] [marker string] [into (ptr buffer)] [err (ptr buffer)]) -> i32
-  (let ([top string] [git string] [b (slice u8)] [why string] [prefix ""] [index string] [name (make-buffer)]
-        [got i32 0])
-    (unless (repository a dir (& top) (& git)) (return 0))
+;; git-tracked adds the paths, relative to dir, of the regular files the index lists under dir. It sets marked when they
+;; include dir's marker file.
+(define (git-tracked [a (ptr arena)] [dir string] [marker string] [into (ptr buffer)] [marked (ptr bool)]
+                     [err (ptr buffer)]) -> bool
+  (let ([top string] [git string] [b (slice u8)] [prefix ""] [index string] [name (make-buffer)] [got i32 0])
+    (set! (@ marked) #f)
+    (unless (repository a dir (& top) (& git)) (return #t))
     (unless (== dir top)
       (let ([p (joined-path (slice dir (if (== top "/") 1 (+ (-> top length) 1))) "")])
         (set! prefix (kept a p))
         (free (-> p bytes))))
     (set! index (joined-path git "index"))
-    (if (< (fs-read-file index (& b) (& why)) 0)
-        (free (-> why bytes))
-        (begin
-          (set! got (listed! a b (oid-size git) prefix marker (& name) into))
-          (free (-> b items))
-          (when (< got 0)
-            (buffer-add-string! err "cannot read the git index at ")
-            (buffer-add-string! err index)
-            (buffer-add-string! err ": sub reads index versions 2 to 4, but not a split or sparse index"))))
+    (when (fs-read-file index (& b) 0)
+      (set! got (listed! a b (oid-size git) prefix marker (& name) into))
+      (free (-> b items))
+      (when (< got 0)
+        (buffer-add-string! err "cannot read the git index at ")
+        (buffer-add-string! err index)
+        (buffer-add-string! err ": sub reads index versions 2 to 4, but not a split or sparse index")))
     (buffer-free! (& name))
     (free (-> index bytes))
-    got))
+    (set! (@ marked) (== got 1))
+    (>= got 0)))
 
 ;; repository finds the working tree holding dir, and its git directory: the .git directory, or the directory a .git file
 ;; points to.
@@ -36,7 +35,7 @@
   (let ([d dir] [info fs-info] [found i32 0])
     (while (== found 0)
       (let ([dot (joined-path d ".git")])
-        (cond [(== (fs-lstat dot (& info) 0) 0)
+        (cond [(fs-lstat dot (& info) 0)
                (set! found -1)
                (cond [(== (-> info kind) fs-directory)
                       (set! (@ git) (kept a dot))
@@ -49,10 +48,8 @@
     (== found 1)))
 
 (define (named-git! [a (ptr arena)] [d string] [dot string] [git (ptr string)]) -> bool
-  (let ([b (slice u8)] [why string] [s string] [end u32 8] [full string])
-    (when (< (fs-read-file dot (& b) (& why)) 0)
-      (free (-> why bytes))
-      (return #f))
+  (let ([b (slice u8)] [s string] [end u32 8] [full string])
+    (unless (fs-read-file dot (& b) 0) (return #f))
     (set! s (cast string b))
     (unless (starts? s "gitdir: ")
       (free (-> b items))
@@ -65,24 +62,20 @@
     #t))
 
 (define (oid-size [git string]) -> u32
-  (let ([common (common-dir git)] [config string] [b (slice u8)] [why string] [size u32 20])
+  (let ([common (common-dir git)] [config string] [b (slice u8)] [size u32 20])
     (set! config (joined-path common "config"))
-    (if (< (fs-read-file config (& b) (& why)) 0)
-        (free (-> why bytes))
-        (begin
-          (when (sha256-objects? (cast string b)) (set! size 32))
-          (free (-> b items))))
+    (when (fs-read-file config (& b) 0)
+      (when (sha256-objects? (cast string b)) (set! size 32))
+      (free (-> b items)))
     (free (-> config bytes))
     (free (-> common bytes))
     size))
 
 ;; common-dir gives the main git directory of a worktree, which holds the config.
 (define (common-dir [git string]) -> string
-  (let ([file (joined-path git "commondir")] [b (slice u8)] [why string] [s string] [end u32 0] [out string])
-    (if (< (fs-read-file file (& b) (& why)) 0)
-        (begin
-          (free (-> why bytes))
-          (set! out (string-copy git)))
+  (let ([file (joined-path git "commondir")] [b (slice u8)] [s string] [end u32 0] [out string])
+    (if (not (fs-read-file file (& b) 0))
+        (set! out (string-copy git))
         (begin
           (set! s (cast string b))
           (while (and (< end (-> s length)) (!= (@ s end) 10) (!= (@ s end) 13)) (+= end 1))

package/std/package/hash.sub

@@ -19,9 +19,9 @@
     ok))
 
 (define (hash! [a (ptr arena)] [given string] [w (ptr waiting)] [into (ptr buffer)] [err (ptr buffer)]) -> bool
-  (let ([dir string] [why string] [o w] [m manifest] [paths (make-buffer)] [lines (make-buffer)] [digest (array u8 32)]
+  (let ([dir string] [why error] [o w] [m manifest] [paths (make-buffer)] [lines (make-buffer)] [digest (array u8 32)]
         [ok #t] [me (new a waiting)])
-    (when (< (fs-real-path given (& dir) (& why)) 0) (return (cannot! err why)))
+    (unless (fs-real-path given (& dir) (& why)) (return (cannot! err (& why))))
     (while (and (!= o 0) (!= (-> o dir) dir)) (set! o (-> o next)))
     (when (!= o 0)
       (buffer-add-string! err "the package ")
@@ -79,9 +79,9 @@
     ok))
 
 (define (file-line! [dir string] [path string] [lines (ptr buffer)] [err (ptr buffer)]) -> bool
-  (let ([full (joined-path dir path)] [bytes (slice u8)] [why string] [digest (array u8 32)] [ok #t])
-    (if (< (fs-read-file full (& bytes) (& why)) 0)
-        (set! ok (cannot! err why))
+  (let ([full (joined-path dir path)] [bytes (slice u8)] [why error] [digest (array u8 32)] [ok #t])
+    (if (not (fs-read-file full (& bytes) (& why)))
+        (set! ok (cannot! err (& why)))
         (begin
           (sha256-of bytes (slice digest))
           (add-hex! lines (slice digest))
@@ -92,10 +92,10 @@
     (free (-> full bytes))
     ok))
 
-(define (cannot! [err (ptr buffer)] [why string]) -> bool
+(define (cannot! [err (ptr buffer)] [why (ptr error)]) -> bool
   (buffer-add-string! err "cannot read ")
-  (buffer-add-string! err why)
-  (free (-> why bytes))
+  (buffer-add-string! err (error-text why))
+  (error-free! why)
   #f)
 
 (define (add-hex! [b (ptr buffer)] [bytes (slice u8)])

package/std/package/manifest.sub

@@ -3,16 +3,17 @@
 ;;     (dependencies (name (path "directory") (hash "sha256:hex")) (name (url "address") (hash "sha256:hex")) ...)
 ;;     (tests "path" ... (browser))
 ;;     (sites (name "program.sub" (html "file.html") (files "/dir" (from "directory") "path" ...)) ...))
-;; The substrate clause gives the oldest substrate the package builds with. Every clause but version is optional, and so
-;; are a path dependency's hash and a site's html and files. A files part gives the program the files matching its
-;; paths, from its from directory, under the directory it names; * matches any text in a name and ** any directories.
-;; (browser) says that the package's tests open browsers with std/test/browser.sub.
+;; The substrate clause gives the oldest substrate the package builds with. (substrate "0.10.0") also takes later 0.10
+;; releases, and (substrate "1.2.0") takes later 1.x releases. Every clause but version is optional, and so are a path
+;; dependency's hash and a site's html and files. A files part gives the program the files matching its paths, from its
+;; from directory, under the directory it names; * matches any text in a name and ** any directories. (browser) says
+;; that the package's tests open browsers with std/test/browser.sub.
 (require-unqualified "read.sub")
 (require-unqualified host/fs)
 (require-unqualified "path.sub")
 
 (provide manifest dependency declared-site site-files manifest-read manifest-of-program manifest-find package-holding
-         package-name? full-hash? version-before?)
+         package-name? full-hash? version-before? version-compatible?)
 
 (struct dependency [name string] [path string] [url string] [hash string] [line u32] [column u32])
 (struct site-files [dir string] [from string] [patterns (slice string)])
@@ -24,41 +25,53 @@
 (define default-tests (array string 1))
 
 (define (manifest-read [a (ptr arena)] [file string] [m (ptr manifest)] [err (ptr buffer)]) -> bool
-  (let ([forms (slice data)] [e data-error])
-    (cond [(not (read-forms a file #f (& forms) (& e) err)) #f]
-          [(!= (-> e line) 0) (failed! err file (-> e line) (-> e column) (-> e message))]
-          [(!= (-> forms length) 1) (failed! err file 1 1 "a package.sub holds one form, (package ...)")]
-          [else (manifest-of file (& (@ forms 0)) a m err)])))
+  (let* ([forms (slice data)] [e data-error]
+         [ok (cond [(not (read-forms a file #f (& forms) (& e) err)) #f]
+                   [(!= (-> e line) 0) (failed! err file (-> e line) (-> e column) (error-text (& (-> e error))))]
+                   [(!= (-> forms length) 1) (failed! err file 1 1 "a package.sub holds one form, (package ...)")]
+                   [else (manifest-of file (& (@ forms 0)) a m err)])])
+    (error-free! (& (-> e error)))
+    ok))
 
-(define (manifest-of-program [a (ptr arena)] [file string] [m (ptr manifest)] [err (ptr buffer)]) -> i32
-  (let ([text (slice u8)] [why string] [forms (slice data)] [e data-error] [found i32 -1])
-    (when (< (fs-read-file file (& text) (& why)) 0)
+(define (manifest-of-program [a (ptr arena)] [file string] [m (ptr manifest)] [found (ptr bool)] [err (ptr buffer)])
+  -> bool
+  (let ([text (slice u8)] [why error] [forms (slice data)] [e data-error] [ok #t])
+    (set! (@ found) #f)
+    (unless (fs-read-file file (& text) (& why))
       (buffer-add-string! err "cannot read ")
-      (buffer-add-string! err why)
-      (free (-> why bytes))
-      (return -1))
-    (cond [(!= (data-head a (cast string text)) "package") (set! found 0)]
-          [(not (data-read a (cast string text) #t (& forms) (& e))) (failed! err file (-> e line) (-> e column) (-> e message))]
-          [(manifest-of file (& (@ forms 0)) a m err) (set! found 1)])
+      (buffer-add-string! err (error-text (& why)))
+      (error-free! (& why))
+      (return #f))
+    (cond [(!= (data-head a (cast string text)) "package") (begin)]
+          [(not (data-read a (cast string text) #t (& forms) (& e)))
+           (set! ok (failed! err file (-> e line) (-> e column) (error-text (& (-> e error)))))]
+          [(manifest-of file (& (@ forms 0)) a m err) (set! (@ found) #t)]
+          [else (set! ok #f)])
+    (error-free! (& (-> e error)))
     (free (-> text items))
-    found))
+    ok))
 
-;; manifest-find finds the manifest of the package that holds the program in file, given from /: the program's own,
-;; giving 1, or the nearest package.sub above it, giving 2, with the package's directory added to dir. It gives 0 when
-;; there is none, and -1 with err saying why when the manifest is wrong.
-(define (manifest-find [a (ptr arena)] [file string] [m (ptr manifest)] [dir (ptr buffer)] [err (ptr buffer)]) -> i32
-  (let ([own (manifest-of-program a file m err)] [d string] [found i32 0])
-    (when (!= own 0) (return own))
+;; manifest-find finds the manifest for the program in file, given from /. found is 1 for the program's own manifest,
+;; 2 for the nearest package.sub above it, whose directory goes into dir, and 0 when there is none.
+(define (manifest-find [a (ptr arena)] [file string] [m (ptr manifest)] [dir (ptr buffer)] [found (ptr i32)]
+                       [err (ptr buffer)]) -> bool
+  (let ([own #f] [d string])
+    (set! (@ found) 0)
+    (unless (manifest-of-program a file m (& own) err) (return #f))
+    (when own
+      (set! (@ found) 1)
+      (return #t))
     (set! d (package-holding a (parent-of file)))
     (when (> (-> d length) 0)
-      (set! found (if (manifest-read a (joined-path d "package.sub") m err) 2 -1))
-      (when (== found 2) (buffer-add-string! dir d)))
-    found))
+      (unless (manifest-read a (joined-path d "package.sub") m err) (return #f))
+      (set! (@ found) 2)
+      (buffer-add-string! dir d))
+    #t))
 
 (define (package-holding [a (ptr arena)] [dir string]) -> string
   (let ([d dir] [info fs-info] [found ""])
     (while (> (-> d length) 0)
-      (when (and (== (fs-stat (joined-path d "package.sub") (& info) 0) 0) (== (-> info kind) fs-file))
+      (when (and (fs-stat (joined-path d "package.sub") (& info) 0) (== (-> info kind) fs-file))
         (set! found (copy a d))
         (break))
       (set! d (if (root-path? d) "" (parent-of d))))
@@ -66,12 +79,12 @@
 
 (define (read-forms [a (ptr arena)] [file string] [first bool] [into (ptr (slice data))] [e (ptr data-error)]
                     [err (ptr buffer)]) -> bool
-  (let ([text (slice u8)] [why string])
+  (let ([text (slice u8)] [why error])
     (set! (-> e line) 0)
-    (when (< (fs-read-file file (& text) (& why)) 0)
+    (unless (fs-read-file file (& text) (& why))
       (buffer-add-string! err "cannot read ")
-      (buffer-add-string! err why)
-      (free (-> why bytes))
+      (buffer-add-string! err (error-text (& why)))
+      (error-free! (& why))
       (return #f))
     (unless (data-read a (cast string text) first into e)
       (when (== (-> e line) 0) (set! (-> e line) 1)))
@@ -132,17 +145,29 @@
 
 ;; version-before? is whether version a comes before version b, both major.minor.patch. No version comes before "".
 (define (version-before? [a string] [b string]) -> bool
-  (let ([i u32 0] [j u32 0] [x i64 0] [y i64 0])
+  (let ([i u32 0] [j u32 0])
     (for ([k u32 0]) (< k 3) (+= k 1)
-      (set! x 0)
-      (set! y 0)
-      (while (and (< i (-> a length)) (!= (@ a i) #\.)) (set! x (+ (* x 10) (cast i64 (- (@ a i) #\0)))) (+= i 1))
-      (while (and (< j (-> b length)) (!= (@ b j) #\.)) (set! y (+ (* y 10) (cast i64 (- (@ b j) #\0)))) (+= j 1))
-      (+= i 1)
-      (+= j 1)
-      (when (!= x y) (return (< x y))))
+      (let ([x (version-part a (& i))] [y (version-part b (& j))])
+        (when (!= x y) (return (< x y)))))
     #f))
 
+(define (version-compatible? [a string] [b string]) -> bool
+  (let ([i u32 0] [j u32 0])
+    (when (== (-> b length) 0) (return #t))
+    (for ([k u32 0]) (< k 2) (+= k 1)
+      (let ([x (version-part a (& i))] [y (version-part b (& j))])
+        (when (!= x y) (return #f))
+        (when (!= y 0) (break))))
+    (not (version-before? a b))))
+
+(define (version-part [s string] [at (ptr u32)]) -> i64
+  (let ([n i64 0])
+    (while (and (< (@ at) (-> s length)) (!= (@ s (@ at)) #\.))
+      (set! n (+ (* n 10) (cast i64 (- (@ s (@ at)) #\0))))
+      (+= (@ at) 1))
+    (+= (@ at) 1)
+    n))
+
 (define (manifest-of [file string] [f (ptr data)] [a (ptr arena)] [m (ptr manifest)] [err (ptr buffer)]) -> bool
   (let ([items (items-of f)] [versioned #f] [needed #f] [exported #f] [listed #f] [tested #f] [sited #f] [major i64 0])
     (set! (-> m substrate) "")

package/std/package/map.sub

@@ -78,7 +78,7 @@
               (set! (@ dirs i) (normal-path a full))
               (free (-> full bytes))))
         (when (and (> (-> d url length) 0)
-                   (or (!= (fs-stat (@ dirs i) (& info) 0) 0) (!= (-> info kind) fs-directory)))
+                   (or (not (fs-stat (@ dirs i) (& info) 0)) (!= (-> info kind) fs-directory)))
           (buffer-add-string! err (-> d name))
           (buffer-add-string! err ", from ")
           (buffer-add-string! err (-> d url))

package/std/package/pack.sub

@@ -23,9 +23,9 @@
   (let ([pack (make-buffer)] [ok #t] [fs (cast (ptr packed-file) (-> files bytes))]
         [n (/ (-> files length) (sizeof packed-file))])
     (for ([k u32 0]) (and ok (< k n)) (+= k 1)
-      (let ([name (-> (@ fs k) name)] [why string] [bytes (slice u8)])
-        (if (< (fs-read-file (-> (@ fs k) path) (& bytes) (& why)) 0)
-            (set! ok (failed! err "cannot read " why))
+      (let ([name (-> (@ fs k) name)] [why error] [bytes (slice u8)])
+        (if (not (fs-read-file (-> (@ fs k) path) (& bytes) (& why)))
+            (set! ok (failed! err "cannot read " (& why)))
             (begin
               (buffer-add-u32! (& pack) (-> name length))
               (buffer-add-string! (& pack) name)
@@ -33,8 +33,8 @@
               (buffer-add! (& pack) bytes)
               (free (-> bytes items))))))
     (when ok
-      (let ([why string])
-        (when (< (fs-write-file out (buffer-bytes (& pack)) (& why)) 0) (set! ok (failed! err "cannot write " why)))))
+      (let ([why error])
+        (unless (fs-write-file out (buffer-bytes (& pack)) (& why)) (set! ok (failed! err "cannot write " (& why))))))
     (for ([k u32 0]) (< k n) (+= k 1)
       (free (-> (-> (@ fs k) name) bytes))
       (free (-> (-> (@ fs k) path) bytes)))
@@ -50,22 +50,22 @@
     (buffer-add-string! (& b) name)
     (buffer-string (& b))))
 
-(define (failed! [err (ptr buffer)] [what string] [why string]) -> bool
+(define (failed! [err (ptr buffer)] [what string] [why (ptr error)]) -> bool
   (buffer-add-string! err what)
-  (buffer-add-string! err why)
-  (free (-> why bytes))
+  (buffer-add-string! err (error-text why))
+  (error-free! why)
   #f)
 
 (define (add! [dir string] [name string] [at string] [files (ptr buffer)] [err (ptr buffer)]) -> bool
-  (let* ([full (joined dir name)] [why string] [info fs-info] [ok #t])
-    (cond [(< (fs-stat full (& info) (& why)) 0)
-           (set! ok (failed! err "cannot read " why))
+  (let* ([full (joined dir name)] [why error] [info fs-info] [ok #t])
+    (cond [(not (fs-stat full (& info) (& why)))
+           (set! ok (failed! err "cannot read " (& why)))
            (free (-> name bytes))
            (free (-> full bytes))]
           [(== (-> info kind) fs-directory)
            (let ([listed (slice string)])
-             (if (< (fs-list full (& listed) (& why)) 0)
-                 (set! ok (failed! err "cannot read " why))
+             (if (not (fs-list full (& listed) (& why)))
+                 (set! ok (failed! err "cannot read " (& why)))
                  (begin
                    (for ([j u32 0]) (and ok (< j (-> listed length))) (+= j 1)
                      (set! ok (add! dir (joined name (@ listed j)) at files err)))

package/std/package/read.sub

@@ -7,7 +7,7 @@
   [data-symbol [text string] [line u32] [column u32]]
   [data-string [text string] [line u32] [column u32]])
 
-(struct data-error [message string] [line u32] [column u32])
+(struct data-error [error error] [line u32] [column u32])
 
 (struct data-reader [text string] [at u32] [line u32] [column u32] [arena (ptr arena)] [error (ptr data-error)])
 
@@ -34,13 +34,13 @@
     #t))
 
 (define (data-head [a (ptr arena)] [text string]) -> string
-  (let ([r data-reader] [e data-error] [start u32 0])
+  (let ([r data-reader] [start u32 0])
     (set! (-> r text) text)
     (set! (-> r at) 0)
     (set! (-> r line) 1)
     (set! (-> r column) 1)
     (set! (-> r arena) a)
-    (set! (-> r error) (& e))
+    (set! (-> r error) 0)
     (unless (and (skip-space! (& r)) (more? (& r)) (or (== (here (& r)) #\() (== (here (& r)) #\[))) (return ""))
     (advance! (& r))
     (unless (skip-space! (& r)) (return ""))
@@ -93,9 +93,10 @@
   (or (== c 32) (and (>= c 9) (<= c 13)) (== c #\() (== c #\)) (== c #\[) (== c #\]) (== c #\") (== c 59)))
 
 (define (failed! [r (ptr data-reader)] [message string] [line u32] [column u32]) -> bool
-  (set! (-> r error message) message)
-  (set! (-> r error line) line)
-  (set! (-> r error column) column)
+  (unless (== (-> r error) 0)
+    (error-fail! (& (-> r error error)) error-invalid message)
+    (set! (-> r error line) line)
+    (set! (-> r error column) column))
   #f)
 
 (define (read-one! [r (ptr data-reader)] [into (ptr data)]) -> bool

package/std/package/site.sub

@@ -23,18 +23,18 @@
   (let ([info fs-info]) (fs-stat path (& info) 0) (-> info kind)))
 
 (define (made! [path string])
-  (let ([why string]) (when (< (fs-make-dir path (& why)) 0) (throw site-failed why))))
+  (let ([why error]) (unless (fs-make-dir path (& why)) (throw site-failed (error-text (& why))))))
 
 (define (copied! [from string] [to string])
-  (let ([why string]) (when (< (fs-copy from to (& why)) 0) (throw site-failed why))))
+  (let ([why error]) (unless (fs-copy from to (& why)) (throw site-failed (error-text (& why))))))
 
 (define (names-in [dir string]) -> (slice string)
-  (let ([names (slice string)] [why string])
-    (when (< (fs-list dir (& names) (& why)) 0) (throw site-failed why))
+  (let ([names (slice string)] [why error])
+    (unless (fs-list dir (& names) (& why)) (throw site-failed (error-text (& why))))
     names))
 
 (define (written! [path string] [b (slice u8)])
-  (let ([why string]) (when (< (fs-write-file path b (& why)) 0) (throw site-failed why))))
+  (let ([why error]) (unless (fs-write-file path b (& why)) (throw site-failed (error-text (& why))))))
 
 (define (copy-tree! [from string] [to string] [base string] [files (ptr buffer)])
   (let ([names (names-in from)])
@@ -131,12 +131,12 @@
         #f]))
 
 (define (site-written! [p (ptr site-plan)] [out string] [toolchain string])
-  (let ([list (make-buffer)] [files (make-buffer)] [packed (make-buffer)] [err (make-buffer)] [why string])
+  (let ([list (make-buffer)] [files (make-buffer)] [packed (make-buffer)] [err (make-buffer)] [why error])
     (when (and (!= (kind-of out) fs-none)
                (or (!= (kind-of out) fs-directory)
                    (and (> (-> (names-in out) length) 0) (!= (kind-of (joined-path out ".site")) fs-file))))
       (throw site-failed (joined (joined "site: " out) " is not a site, so it is not replaced")))
-    (when (and (!= (kind-of out) fs-none) (< (fs-remove out #t (& why)) 0)) (throw site-failed why))
+    (when (and (!= (kind-of out) fs-none) (not (fs-remove out #t (& why)))) (throw site-failed (error-text (& why))))
     (made! (joined-path out "host/modules"))
     (made! (joined-path out "host/web"))
     (written! (joined-path out ".site") (cast (slice u8) (joined (-> p program) "\n")))

package/std/package/store.sub

@@ -24,7 +24,7 @@
       (let* ([d (& (@ deps i))] [url (> (-> d url length) 0)] [dm manifest] [err (make-buffer)] [info fs-info]
              [next (if url (store-entry a store (-> d hash)) (dependency-dir a dir (-> d path)))]
              [file (joined-path next "package.sub")])
-        (if (and url (or (!= (fs-stat next (& info) 0) 0) (!= (-> info kind) fs-directory)))
+        (if (and url (or (not (fs-stat next (& info) 0)) (!= (-> info kind) fs-directory)))
             (let ([w wanted])
               (set! (-> w name) (-> d name))
               (set! (-> w url) (-> d url))
@@ -45,8 +45,8 @@
 (define (store-install! [a (ptr arena)] [store string] [staging string] [pin string] [m (ptr manifest)]
                         [into (ptr buffer)] [err (ptr buffer)]) -> bool
   (let ([file (joined-path staging "package.sub")] [info fs-info] [h (make-buffer)] [hash string] [entry string]
-        [kept string] [why string])
-    (unless (and (== (fs-stat file (& info) 0) 0) (== (-> info kind) fs-file))
+        [kept string] [why error])
+    (unless (and (fs-stat file (& info) 0) (== (-> info kind) fs-file))
       (return (not-installed! staging err "it has no package.sub at its top")))
     (unless (manifest-read a file m err) (return (not-installed! staging err "")))
     (let ([deps (-> m dependencies)])
@@ -64,18 +64,21 @@
       (buffer-add-string! err ", not the one its dependency pins, ")
       (return (not-installed! staging err pin)))
     (set! entry (store-entry a store hash))
-    (when (< (fs-make-temp-dir store ".staging-" "" (& kept) (& why)) 0)
-      (buffer-add-string! err why)
+    (unless (fs-make-temp-dir store ".staging-" "" (& kept) (& why))
+      (buffer-add-string! err (error-text (& why)))
+      (error-free! (& why))
       (return (not-installed! staging err "")))
     (unless (copied! a staging staging kept err)
       (fs-remove kept #t 0)
       (return (not-installed! staging err "")))
     (fs-remove staging #t 0)
-    (when (< (fs-rename kept entry (& why)) 0)
+    (unless (fs-rename kept entry (& why))
       (fs-remove kept #t 0)
-      (unless (and (== (fs-stat entry (& info) 0) 0) (== (-> info kind) fs-directory))
-        (buffer-add-string! err why)
-        (return #f)))
+      (unless (and (fs-stat entry (& info) 0) (== (-> info kind) fs-directory))
+        (buffer-add-string! err (error-text (& why)))
+        (error-free! (& why))
+        (return #f))
+      (error-free! (& why)))
     (buffer-add-string! into hash)
     #t))
 
@@ -95,9 +98,10 @@
     ok))
 
 (define (copied-file! [top string] [dir string] [p string] [to string] [err (ptr buffer)]) -> bool
-  (let* ([from (joined-path dir p)] [dest (joined-path to (slice from (+ (-> top length) 1)))] [why string] [ok #t])
-    (when (or (< (fs-make-dir (parent-of dest) (& why)) 0) (< (fs-copy from dest (& why)) 0))
-      (buffer-add-string! err why)
+  (let* ([from (joined-path dir p)] [dest (joined-path to (slice from (+ (-> top length) 1)))] [why error] [ok #t])
+    (unless (and (fs-make-dir (parent-of dest) (& why)) (fs-copy from dest (& why)))
+      (buffer-add-string! err (error-text (& why)))
+      (error-free! (& why))
       (set! ok #f))
     (free (-> from bytes))
     (free (-> dest bytes))

package/std/package.sub

@@ -1,13 +1,13 @@
 (package std
-  (version "0.9.0")
-  (substrate "0.9.0")
+  (version "0.10.0")
+  (substrate "0.10.0")
   (exports archive/tar browser/chromium browser/devtools compress/deflate compress/gzip compress/inflate crypto/hmac
            crypto/password crypto/sha1
            crypto/sha256 crypto/sha512 doc/doc doc/html doc/root doc/text encoding/base64 encoding/json encoding/utf8
            encoding/wire html/html http/checks http/conditional http/cookie http/form http/http http/multipart
            http/route http/server http/session http/sse http/sse-client http/static http/test http/token http/url
-           http/websocket log/log meta/derive meta/equal meta/type-info package/files package/hash package/manifest
-           package/map package/pack package/path package/read package/site package/store test/browser test/build
-           test/run test/session test/test web/canvas web/dom web/gpu web/patches)
+           http/websocket log/log meta/derive meta/equal meta/method meta/type-info package/files package/hash
+           package/manifest package/map package/pack package/path package/read package/site package/store test/browser
+           test/build test/run test/session test/test vector/vector web/canvas web/dom web/gpu web/patches)
   (tests "tests/archive/*.sub" "tests/compress/*.sub" "tests/crypto/*.sub" "tests/encoding/*.sub" "tests/http/*.sub"
-         "tests/log/*.sub" "tests/meta/*.sub" "tests/test/*.sub"))
+         "tests/log/*.sub" "tests/meta/*.sub" "tests/test/*.sub" "tests/vector/*.sub"))

package/std/test/browser.sub

@@ -111,8 +111,9 @@
     (unless (env-get "SUBSTRATE_DEVTOOLS" (& address) 0)
       (throw test-failed (lines-joined message "a test that opens a browser needs (browser) in the tests clause of its package's package.sub")))
     (when (== (-> address length) 0) (throw test-skipped "need Chromium"))
-    (let* ([dir (site-built spec html message)] [why string] [p (page-open dir (with-args url args) address server (& why))])
-      (when (== (cast u32 p) 0) (throw test-failed (lines-joined message why)))
+    (let ([dir (site-built spec html message)] [why error] [p (ptr page) 0])
+      (unless (page-open dir (with-args url args) address server (& p) (& why))
+        (throw test-failed (lines-joined message (error-text (& why)))))
       (browser #:page p))))
 
 ;; Adds args to url as arg parameters, which a site passes to its program as its arguments.
@@ -143,7 +144,7 @@
       (when (> (-> html length) 0) (set! (-> p html) html))
       (unless (site-write! (& p) dir (toolchain) (& err))
         (throw test-failed (lines-joined message (buffer-string (& err)))))
-      (unless (and (== (fs-stat (-> p program) (& info) 0) 0) (== (-> info kind) fs-directory))
+      (unless (and (fs-stat (-> p program) (& info) 0) (== (-> info kind) fs-directory))
         (unless (program-write! (-> p program) (joined-path dir "program") (& err))
           (throw test-failed (lines-joined message (buffer-string (& err)))))))
     (set! b (built #:spec spec #:html html #:dir dir))
@@ -152,8 +153,8 @@
 
 ;; spec is the name of a site the package declares, or else the path of a program.
 (define (planned [spec string] [name string] [message string]) -> site-plan
-  (let ([p site-plan] [a (make-arena)] [here string] [why string] [err (make-buffer)])
-    (when (< (fs-cwd (& here) (& why)) 0) (throw test-failed (lines-joined message why)))
+  (let ([p site-plan] [a (make-arena)] [here string] [why error] [err (make-buffer)])
+    (unless (fs-cwd (& here) (& why)) (throw test-failed (lines-joined message (error-text (& why)))))
     (if (site-named? spec)
         (unless (site-declared (& a) here spec (& p) (& err)) (throw test-failed (lines-joined message (buffer-string (& err)))))
         (set! p (site-plan #:name name #:program (resolved-path here spec) #:html ""
@@ -173,12 +174,12 @@
 
 ;; Saves a PNG of the browser's window as build/test/screenshots/name.png in the package, and gives that path.
 (define (browser-screenshot [b browser] [name string]) -> string
-  (let* ([dir "build/test/screenshots"] [file (make-buffer)] [why string] [png (page-screenshot (-> b page))])
+  (let* ([dir "build/test/screenshots"] [file (make-buffer)] [why error] [png (page-screenshot (-> b page))])
     (buffer-add-string! (& file) name)
     (buffer-add-string! (& file) ".png")
     (let ([path (joined-path dir (buffer-string (& file)))])
-      (when (or (< (fs-make-dir dir (& why)) 0) (< (fs-write-file path png (& why)) 0))
-        (throw test-failed (page-stepped why)))
+      (unless (and (fs-make-dir dir (& why)) (fs-write-file path png (& why)))
+        (throw test-failed (page-stepped (error-text (& why)))))
       path)))
 
 (define (lines-joined [a string] [b string]) -> string

package/std/test/build.sub

@@ -17,8 +17,8 @@
 (define (ready!)
   (unless ready
     (set! ready #t)
-    (let ([why string] [toolchain string] [map-file string] [cache string])
-      (when (< (fs-cwd (& directory) (& why)) 0) (throw test-failed why))
+    (let ([why error] [toolchain string] [map-file string] [cache string])
+      (unless (fs-cwd (& directory) (& why)) (throw test-failed (error-text (& why))))
       (env-get "SUBSTRATE_TOOLCHAIN" (& toolchain) 0)
       (env-get "SUBSTRATE_MODULE_MAP" (& map-file) 0)
       (env-get "SUBSTRATE_CACHE" (& cache) 0)