substrate-lang 0.9.3 → 0.10.0

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,55 +25,66 @@
 (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))
-        (set! found (cast string (slice (cast (ptr u8) (arena-alloc a (-> d length))) (-> d length))))
-        (memcpy (-> found bytes) (-> d bytes) (-> d length))
+      (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))))
     found))
 
 (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)))
@@ -133,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) "")
@@ -190,7 +214,7 @@
     (if versioned #t (failed-at! err file f "the package has no (version \"major.minor.patch\")"))))
 
 (define (exports-of [file string] [c (ptr data)] [a (ptr arena)] [m (ptr manifest)] [err (ptr buffer)]) -> bool
-  (let* ([items (items-of c)] [n (- (-> items length) 1)] [es (cast (ptr string) (arena-alloc a (* n (sizeof string))))])
+  (let* ([items (items-of c)] [n (- (-> items length) 1)] [es (new a string n)])
     (for ([i u32 0]) (< i n) (+= i 1)
       (let ([d (& (@ items (+ i 1)))])
         (set! (@ es i) (symbol-of d))
@@ -198,11 +222,11 @@
           (return (failed-at! err file d "an export is the name of a module in the package, as text or lib/value")))
         (for ([k u32 0]) (< k i) (+= k 1)
           (when (== (@ es k) (@ es i)) (return (failed-at! err file d "this export is given twice"))))))
-    (set! (-> m exports) (slice es n))
+    (set! (-> m exports) es)
     #t))
 
 (define (tests-of [file string] [c (ptr data)] [a (ptr arena)] [m (ptr manifest)] [err (ptr buffer)]) -> bool
-  (let* ([items (items-of c)] [n u32 0] [ts (cast (ptr string) (arena-alloc a (* (-> items length) (sizeof string))))])
+  (let* ([items (items-of c)] [n u32 0] [ts (new a string (-> items length))])
     (for ([i u32 1]) (< i (-> items length)) (+= i 1)
       (let ([d (& (@ items i))])
         (cond [(and (list-of? d "browser" 1) (not (-> m test-browser))) (set! (-> m test-browser) #t)]
@@ -210,15 +234,15 @@
               [else
                (return (failed-at! err file d
                                    "a test module is a path in the package, with * for any text, as \"tests/*.sub\", and (browser) comes at most once"))])))
-    (when (> n 0) (set! (-> m tests) (slice ts n)))
+    (when (> n 0) (set! (-> m tests) (slice ts 0 n)))
     #t))
 
 (define (sites-of [file string] [c (ptr data)] [a (ptr arena)] [m (ptr manifest)] [err (ptr buffer)]) -> bool
   (let* ([items (items-of c)] [n (- (-> items length) 1)]
-         [ss (cast (ptr declared-site) (arena-alloc a (* n (sizeof declared-site))))])
+         [ss (new a declared-site n)])
     (for ([i u32 0]) (< i n) (+= i 1)
-      (let* ([d (& (@ items (+ i 1)))] [parts (items-of d)] [s (& (@ ss i))]
-             [groups (cast (ptr site-files) (arena-alloc a (* (-> parts length) (sizeof site-files))))] [g u32 0])
+      (let* ([d (& (@ items (+ i 1)))] [parts (items-of d)] [s (& (@ ss i))] [groups (new a site-files (-> parts length))]
+             [g u32 0])
         (set! (-> s html) "")
         (match d [(data-list p line column) (set! (-> s line) line) (set! (-> s column) column)] [_ (begin)])
         (unless (and (>= (-> parts length) 2) (package-name? (symbol-of (& (@ parts 0))))
@@ -236,12 +260,12 @@
                    (unless (files-of file p a (& (@ groups g)) err) (return #f))
                    (+= g 1)]
                   [else (return (failed-at! err file p site-form))])))
-        (set! (-> s files) (slice groups g))))
-    (set! (-> m sites) (slice ss n))
+        (set! (-> s files) (slice groups 0 g))))
+    (set! (-> m sites) ss)
     #t))
 
 (define (files-of [file string] [c (ptr data)] [a (ptr arena)] [f (ptr site-files)] [err (ptr buffer)]) -> bool
-  (let* ([items (items-of c)] [k u32 2] [n u32 0] [ps (cast (ptr string) (arena-alloc a (* (-> items length) (sizeof string))))])
+  (let* ([items (items-of c)] [k u32 2] [n u32 0] [ps (new a string (-> items length))])
     (set! (-> f from) "")
     (unless (and (>= (-> items length) 3) (string-of (& (@ items 1)) (& (-> f dir))) (starts? (-> f dir) "/"))
       (return (failed-at! err file c files-form)))
@@ -253,7 +277,7 @@
         (return (failed-at! err file (& (@ items i)) files-form)))
       (+= n 1))
     (when (== n 0) (return (failed-at! err file c files-form)))
-    (set! (-> f patterns) (slice ps n))
+    (set! (-> f patterns) (slice ps 0 n))
     #t))
 
 (define site-form string
@@ -272,7 +296,7 @@
 
 (define (dependencies-of [file string] [c (ptr data)] [a (ptr arena)] [m (ptr manifest)] [err (ptr buffer)]) -> bool
   (let* ([items (items-of c)] [n (- (-> items length) 1)]
-         [ds (cast (ptr dependency) (arena-alloc a (* n (sizeof dependency))))])
+         [ds (new a dependency n)])
     (for ([i u32 0]) (< i n) (+= i 1)
       (let* ([d (& (@ items (+ i 1)))] [parts (items-of d)] [dep (& (@ ds i))])
         (set! (-> dep path) "")
@@ -302,7 +326,7 @@
           (return (failed-at! err file d "a dependency's url starts with http:// or https://")))
         (when (and (> (-> dep url length) 0) (not (full-hash? (-> dep hash))))
           (return (failed-at! err file d "a url's hash is sha256: and 64 hex digits, as substrate hash prints it")))))
-    (set! (-> m dependencies) (slice ds n))
+    (set! (-> m dependencies) ds)
     #t))
 
 (define dependency-form string

package/std/package/map.sub

@@ -58,15 +58,12 @@
 (define (visit! [a (ptr arena)] [dir string] [file string] [m (ptr manifest)] [store string] [g (ptr graph)]
                 [err (ptr buffer)]) -> (ptr reached)
   (let* ([deps (-> m dependencies)] [n (-> deps length)]
-         [dirs (cast (ptr string) (arena-alloc a (* n (sizeof string))))]
-         [ms (cast (ptr manifest) (arena-alloc a (* n (sizeof manifest))))]
-         [me (cast (ptr reached) (arena-alloc a (sizeof reached)))] [other (ptr reached) 0])
+         [dirs (new a string n)] [ms (new a manifest n)] [me (new a reached)] [other (ptr reached) 0])
     (set! (-> me m) m)
     (set! (-> me r dir) dir)
     (set! (-> me r file) file)
     (set! (-> me r substrate) (-> m substrate))
-    (set! (-> me r exports) (slice (cast (ptr string) 0) 0))
-    (set! (-> me deps) (cast (ptr (ptr reached)) (arena-alloc a (* n (sizeof (ptr reached))))))
+    (set! (-> me deps) (-> (new a (ptr reached) n) items))
     (set! (-> me hash) "")
     (set! (-> me open) #t)
     (set! (-> me next) 0)
@@ -81,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))
@@ -207,13 +204,12 @@
     ok))
 
 (define (under [a (ptr arena)] [dir string] [b (ptr buffer)]) -> (slice string)
-  (let* ([n (/ (-> b length) (sizeof string))] [ps (cast (ptr string) (-> b bytes))]
-         [out (cast (ptr string) (arena-alloc a (* n (sizeof string))))])
+  (let* ([n (/ (-> b length) (sizeof string))] [ps (cast (ptr string) (-> b bytes))] [out (new a string n)])
     (for ([i u32 0]) (< i n) (+= i 1)
       (let ([full (joined-path dir (@ ps i))])
         (set! (@ out i) (normal-path a full))
         (free (-> full bytes))))
-    (slice out n)))
+    out))
 
 (define (rules! [b (ptr buffer)] [r (ptr package-root)])
   (if (> (-> r file length) 0)

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/path.sub

@@ -21,10 +21,7 @@
 
 (define (root-path? [p string]) -> bool (path-same? (path-windows?) (path-parent (path-windows?) p) p))
 
-(define (kept [a (ptr arena)] [s string]) -> string
-  (let ([out (cast string (slice (cast (ptr u8) (arena-alloc a (-> s length))) (-> s length)))])
-    (memcpy (-> out bytes) (-> s bytes) (-> s length))
-    out))
+(define (kept [a (ptr arena)] [s string]) -> string (copy a s))
 
 (define (within? [p string] [dir string]) -> bool (path-within? (path-windows?) p dir))
 

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 ""))
@@ -48,10 +48,7 @@
     (while (and (more? (& r)) (not (delimiter? (here (& r))))) (advance! (& r)))
     (slice text start (-> r at))))
 
-(define (copied [a (ptr arena)] [b (slice u8)]) -> (ptr u8)
-  (let ([p (cast (ptr u8) (arena-alloc a (-> b length)))])
-    (memcpy p (-> b items) (-> b length))
-    p))
+(define (copied [a (ptr arena)] [b (slice u8)]) -> (ptr u8) (-> (copy a b) items))
 
 (define (here [r (ptr data-reader)]) -> u32 (@ (-> r text) (-> r at)))
 
@@ -96,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
@@ -110,9 +108,7 @@
           [else
            (let ([start (-> r at)])
              (while (and (more? r) (not (delimiter? (here r)))) (advance! r))
-             (set! (@ into) (data-symbol (cast string (slice (copied (-> r arena) (cast (slice u8) (slice (-> r text) start (-> r at))))
-                                                             (- (-> r at) start)))
-                                         line column))
+             (set! (@ into) (data-symbol (copy (-> r arena) (slice (-> r text) start (-> r at))) line column))
              #t)])))
 
 (define (read-list! [r (ptr data-reader)] [close u32] [line u32] [column u32] [into (ptr data)]) -> bool
@@ -162,7 +158,7 @@
                       (return (failed! r "a string's escapes are \\\", \\\\, \\n, \\t, \\r, \\0, and \\x with hex digits and ;" l k))])
                (advance! r))]
             [else (buffer-add-byte! (& b) (cast i32 c)) (advance! r)]))
-    (set! (@ into) (data-string (cast string (slice (copied (-> r arena) (buffer-bytes (& b))) (-> b length))) line column))
+    (set! (@ into) (data-string (cast string (copy (-> r arena) (buffer-bytes (& b)))) line column))
     (buffer-free! (& b))
     #t))
 

package/std/package/site.sub

@@ -19,22 +19,22 @@
     (buffer-add-string! (& out) b)
     (buffer-string (& out))))
 
-(define (kind-of [path string]) -> i32
-  (let ([info fs-info]) (if (< (fs-stat path (& info) 0) 0) 0 (-> info kind))))
+(define (kind-of [path string]) -> fs-kind
+  (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)])
@@ -84,7 +84,7 @@
 ;; Collects the paths under base that match parts k onward; rel is the part of the path matched so far.
 (define (matched! [base string] [rel string] [parts (slice string)] [k u32] [into (ptr buffer)])
   (let ([here (if (== (-> rel length) 0) base (joined-path base rel))])
-    (cond [(== k (-> parts length)) (when (!= (kind-of here) 0) (kept! into rel))]
+    (cond [(== k (-> parts length)) (when (!= (kind-of here) fs-none) (kept! into rel))]
           [(== (@ parts k) "**")
            (matched! base rel parts (+ k 1) into)
            (when (== (kind-of here) fs-directory)
@@ -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])
-    (when (and (!= (kind-of out) 0)
+  (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) 0) (< (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)