substrate-lang 0.9.2 → 0.9.4

package/std/http/server.sub

@@ -39,7 +39,7 @@
   [on-end (fn ((ptr http-request)))]
   [on-gone (fn ((ptr http-request)))] [on-drained (fn ((ptr http-request)))] [body buffer] [limit u32]
   [taken (fn ((ptr http-request) (slice u8)))] [added buffer] [own-head http-head] [etag string] [modified f64]
-  [ranges bool] [compressible bool] [events bool] [encoded bool] [gzip i32] [deflater (ptr deflater)] [crc u32]
+  [ranges bool] [compressible bool] [events bool] [encoded bool] [gzip zip-mode] [deflater (ptr deflater)] [crc u32]
   [size u32])
 
 ;; A check runs before the handler and returns #t when it has answered.
@@ -140,13 +140,11 @@
   (http-write-header! (& (-> r added)) name value))
 
 (define (new-request! [c (ptr http-connection)] [h (ptr http-head)]) -> (ptr http-request)
-  (let ([r (cast (ptr http-request) (calloc 1 (sizeof http-request)))])
+  (let ([r (new 0 http-request)])
     (set! (-> r connection) (cast (ptr void) c))
     (set! (-> r server) (-> c server))
     (set! (-> r length) -1)
-    (set! (-> r peer) (cast string (slice (cast (ptr u8) (arena-alloc (& (-> r arena)) (-> c peer length)))
-                                           (-> c peer length))))
-    (memcpy (-> r peer bytes) (-> c peer bytes) (-> c peer length))
+    (set! (-> r peer) (copy (& (-> r arena)) (-> c peer)))
     (http-head-copy! (& (-> r own-head)) h)
     (set! (-> r head) (& (-> r own-head)))
     (set! (-> r method) (-> r own-head method))
@@ -581,7 +579,7 @@
           [(== kind stream-failed) (drop! c)])))
 
 (define (new-connection! [s (ptr http-server)] [stream u32]) -> (ptr http-connection)
-  (let ([c (cast (ptr http-connection) (calloc 1 (sizeof http-connection)))])
+  (let ([c (new 0 http-connection)])
     (set! (-> c head handle) connection-heard)
     (set! (-> c server) (cast (ptr void) s))
     (set! (-> c stream) stream)
@@ -612,10 +610,7 @@
 ;; ---- compression ----
 
 ;; How an answer is compressed: not, whole by http-send!, as each piece is written, or each event alone.
-(const zip-none i32 0)
-(const zip-whole i32 1)
-(const zip-pieces i32 2)
-(const zip-events i32 3)
+(enum zip-mode zip-none zip-whole zip-pieces zip-events)
 
 ;; Bodies shorter than this go uncompressed.
 (const zip-least i64 1024)
@@ -763,7 +758,7 @@
     (when (and (== (-> r gzip) zip-none) (or (< (-> r length) 0) (>= (-> r length) zip-least)) (zip? r))
       (set! (-> r gzip) (if (-> r events) zip-events zip-pieces))
       (when (== (-> r gzip) zip-pieces)
-        (set! (-> r deflater) (cast (ptr deflater) (malloc (sizeof deflater))))
+        (set! (-> r deflater) (new 0 deflater))
         (deflater-init! (-> r deflater) (-> s compress))))
     (when (and (has-length? r) (>= (-> r length) 0) (< (-> r gzip) zip-pieces))
       (http-write-number! b "content-length" (-> r length)))
@@ -911,7 +906,7 @@
         (begin
           (stream-close from)
           (http-finish! r))
-        (let ([p (cast (ptr relay) (malloc (sizeof relay)))])
+        (let ([p (new 0 relay)])
           (http-write! r 0)
           (set! (-> p head handle) relay-heard)
           (set! (-> p from) from)

package/std/http/session.sub

@@ -51,10 +51,7 @@
       (set! ok (and (<= at (+ (now-seconds) 60)) (<= (cast i64 (- (now-seconds) at)) (max-age-of s)))))
     (set! (-> b length) 0)
     (set! ok (and ok (base64url-decode! (& b) (slice value 0 first))))
-    (when ok
-      (let ([p (cast (ptr u8) (arena-alloc (& (-> r arena)) (-> b length)))])
-        (memcpy p (-> b bytes) (-> b length))
-        (set! (@ into) (slice p (-> b length)))))
+    (when ok (set! (@ into) (copy (& (-> r arena)) (buffer-bytes (& b)))))
     (buffer-free! (& b))
     ok))
 

package/std/http/sse-client.sub

@@ -11,16 +11,11 @@
 (require-unqualified "http.sub")
 
 (provide sse-event sse-parser sse-parser-init! sse-parse! sse-parser-end! sse-parser-free! sse-client
-         sse-client-open! sse-client-close! sse-ended sse-lost sse-refused)
+         sse-client-open! sse-client-close! sse-end sse-ended sse-lost sse-refused)
 
-(const sse-ended i32 0)
-(const sse-lost i32 1)
-(const sse-refused i32 2)
+(enum sse-end sse-ended sse-lost sse-refused)
 
-(const state-closed i32 0)
-(const state-connecting i32 1)
-(const state-open i32 2)
-(const state-waiting i32 3)
+(enum client-state state-closed state-connecting state-open state-waiting)
 
 (const default-retry f64 3000.0)
 
@@ -133,10 +128,10 @@
 ;; ---- the client ----
 
 (struct sse-client [head event-head] [user (ptr void)] [reconnect bool] [retry f64] [status i32] [error i32]
-  [method string] [url string] [headers (slice string)] [body (slice u8)] [state i32] [fetch u32] [timer u32]
+  [method string] [url string] [headers (slice string)] [body (slice u8)] [state client-state] [fetch u32] [timer u32]
   [parser sse-parser] [chunk (array u8 16384)]
   [on-open (fn ((ptr sse-client)))] [on-event (fn ((ptr sse-client) (ptr sse-event)))]
-  [on-closed (fn ((ptr sse-client) i32))])
+  [on-closed (fn ((ptr sse-client) sse-end))])
 
 (define (parsed [p (ptr sse-parser)] [e (ptr sse-event)])
   (let ([c (cast (ptr sse-client) (-> p user))])
@@ -144,7 +139,7 @@
 
 (define (connect! [c (ptr sse-client)])
   (let* ([n (-> c headers length)] [id (buffer-string (& (-> c parser id)))]
-         [all (cast (ptr string) (malloc (* (+ n 4) (sizeof string))))] [k n])
+         [all (new 0 string (+ n 4))] [k n])
     (for ([i u32 0]) (< i n) (+= i 1) (set! (@ all i) (@ (-> c headers) i)))
     (set! (@ all k) "accept")
     (set! (@ all (+ k 1)) "text/event-stream")
@@ -154,8 +149,8 @@
       (set! (@ all (+ k 1)) id)
       (+= k 2))
     (set! (-> c state) state-connecting)
-    (set! (-> c fetch) (fetch-start (-> c method) (-> c url) (slice all k) (-> c body) (cast (ptr void) c)))
-    (free all)))
+    (set! (-> c fetch) (fetch-start (-> c method) (-> c url) (slice all 0 k) (-> c body) (cast (ptr void) c)))
+    (free (-> all items))))
 
 (define (stop! [c (ptr sse-client)])
   (unless (== (-> c fetch) 0) (stream-close (-> c fetch)))
@@ -164,7 +159,7 @@
   (set! (-> c timer) 0)
   (set! (-> c state) state-closed))
 
-(define (ended! [c (ptr sse-client)] [why i32])
+(define (ended! [c (ptr sse-client)] [why sse-end])
   (stream-close (-> c fetch))
   (set! (-> c fetch) 0)
   (sse-parser-end! (& (-> c parser)))

package/std/http/url.sub

@@ -26,7 +26,7 @@
     (for ([i u32 0]) (< i n) (+= i 1)
       (when (or (escape? s i) (and plus (== (@ s i) #\+))) (set! plain #f)))
     (when plain (return s))
-    (let ([p (cast (ptr u8) (arena-alloc a n))] [i u32 0] [k u32 0])
+    (let ([p (new a u8 n)] [i u32 0] [k u32 0])
       (while (< i n)
         (cond [(escape? s i)
                (set! (@ p k) (+ (* 16 (digit-value (@ s (+ i 1)) 16)) (digit-value (@ s (+ i 2)) 16)))
@@ -38,7 +38,7 @@
                (set! (@ p k) (@ s i))
                (+= i 1)])
         (+= k 1))
-      (cast string (slice p k)))))
+      (cast string (slice p 0 k)))))
 
 ;; A path's segments after its first slash, decoded into the arena: "/" has none, and a final slash gives an empty last
 ;; segment. It returns 1 when a segment is . or .., or empty before the end, and -1 when the path does not start with a
@@ -49,7 +49,7 @@
     (when (or (== n 0) (!= (@ path 0) #\/)) (return -1))
     (when (== n 1) (return 0))
     (for ([i u32 1]) (< i n) (+= i 1) (when (== (@ path i) #\/) (+= count 1)))
-    (let ([items (cast (ptr string) (arena-alloc a (* count (sizeof string))))])
+    (let ([items (new a string count)])
       (for ([i u32 1]) (<= i n) (+= i 1)
         (when (or (== i n) (== (@ path i) #\/))
           (let ([s (url-unescape a (slice path start i) #f)])
@@ -57,12 +57,12 @@
             (set! (@ items k) s)
             (+= k 1)
             (set! start (+ i 1)))))
-      (set! (@ to) (slice items k))
+      (set! (@ to) (slice items 0 k))
       (if unclean 1 0))))
 
 ;; The path the segments name, resolved as Go's path.Clean does, keeping a final slash.
 (define (url-add-clean! [b (ptr buffer)] [segments (slice string)])
-  (let* ([n (-> segments length)] [kept (cast (ptr u32) (malloc (* 4 (+ n 1))))] [k u32 0]
+  (let* ([n (-> segments length)] [kept (new 0 u32 (+ n 1))] [k u32 0]
          [last (if (> n 0) (@ segments (- n 1)) "x")] [slash (or (== last "") (== last ".") (== last ".."))])
     (for ([i u32 0]) (< i n) (+= i 1)
       (let ([s (@ segments i)])
@@ -76,7 +76,7 @@
       (buffer-add-byte! b #\/)
       (url-add-segment! b (@ segments (@ kept j))))
     (when (and slash (> k 0)) (buffer-add-byte! b #\/))
-    (free kept)))
+    (free (-> kept items))))
 
 (define hex-digits string "0123456789ABCDEF")
 
@@ -109,17 +109,17 @@
 (define (url-form-parse [a (ptr arena)] [s string]) -> (slice url-pair)
   (let ([n (-> s length)] [count u32 1] [k u32 0] [start u32 0])
     (for ([i u32 0]) (< i n) (+= i 1) (when (== (@ s i) #\&) (+= count 1)))
-    (let ([pairs (cast (ptr url-pair) (arena-alloc a (* count (sizeof url-pair))))])
+    (let ([pairs (new a url-pair count)])
       (for ([i u32 0]) (<= i n) (+= i 1)
         (when (or (== i n) (== (@ s i) #\&))
           (when (> i start)
             (let ([part (slice s start i)] [e u32 0])
               (while (and (< e (-> part length)) (!= (@ part e) #\=)) (+= e 1))
-              (set! (-> (+ pairs k) name) (url-unescape a (slice part 0 e) #t))
-              (set! (-> (+ pairs k) value) (url-unescape a (if (< e (-> part length)) (slice part (+ e 1)) "") #t))
+              (set! (-> (@ pairs k) name) (url-unescape a (slice part 0 e) #t))
+              (set! (-> (@ pairs k) value) (url-unescape a (if (< e (-> part length)) (slice part (+ e 1)) "") #t))
               (+= k 1)))
           (set! start (+ i 1))))
-      (slice pairs k))))
+      (slice pairs 0 k))))
 
 ;; The value of the first pair with the name.
 (define (url-form-value [pairs (slice url-pair)] [name string] [to (ptr string)]) -> bool

package/std/http/websocket.sub

@@ -19,14 +19,11 @@
 ;; A message beyond this many bytes closes the connection with 1009.
 (const largest u32 16777216)
 
-(const state-open i32 0)
-(const state-closing i32 1)
-(const state-finishing i32 2)
-(const state-closed i32 3)
+(enum ws-state state-open state-closing state-finishing state-closed)
 
 (struct ws-connection [head event-head] [stream u32] [user (ptr void)] [server (ptr http-server)] [ping f64]
   [hook http-hook] [frames buffer] [message buffer] [out buffer]
-  [kind i32] [state i32] [code i32] [reading bool] [full bool] [timer u32] [timer-at f64] [heard f64] [pinged bool]
+  [kind i32] [state ws-state] [code i32] [reading bool] [full bool] [timer u32] [timer-at f64] [heard f64] [pinged bool]
   [any-origin bool]
   [on-message (fn ((ptr ws-connection) (slice u8) i32))]
   [on-closed (fn ((ptr ws-connection) i32))]

package/std/meta/type-info.sub

@@ -3,17 +3,17 @@
 
 (provide type-info variable-type type-datum)
 
-;; (kind name items parameters), kind struct, union or variant, or 0 when t names none. A struct's or union's items are
-;; (field . type), a variant's (case (field . type) ...). A type is i8 to u64, f32, f64, bool or string, (ptr type),
-;; (slice type), (array type n), a struct's, union's or variant's identifier, (identifier type ...) for one with
-;; parameters, or (other type). For (identifier type ...), the items have those types in place of the parameters, and the
-;; parameters are ().
+;; (kind name items parameters), kind struct, union, variant or enum, or 0 when t names none. A struct's or union's items
+;; are (field . type), a variant's (case (field . type) ...) and an enum's (case). A type is i8 to u64, f32, f64, bool or
+;; string, (ptr type), (slice type), (array type n), a struct's, union's, variant's or enum's identifier,
+;; (identifier type ...) for one with parameters, or (other type). For (identifier type ...), the items have those types
+;; in place of the parameters, and the parameters are ().
 (define (type-info [t datum]) -> datum
   (let ([instance (pair? t)])
     (syntax-match (binding-of (if instance (car t) t))
-      [('substrate-struct name (item ...) kind (p ...))
+      [('substrate-struct name (item ...) kind (p ...) . _)
        (let ([k (syntax-e kind)] [env (if instance (for/list ([q p] [a (cdr t)]) (cons (syntax-e q) a)) nil)])
-         `(,k ,name ,(for/list ([i item]) (if (== k 'variant) (case-info i env) (field-info i env)))
+         `(,k ,name ,(for/list ([i item]) (if (!= (memq k '(variant enum)) 0) (case-info i env) (field-info i env)))
            ,(if instance nil p)))]
       [('substrate-typedef u)
        (let ([d (parsed-type (syntax->datum u))])
@@ -37,7 +37,7 @@
      (cond [(!= (memq (syntax-e x) scalars) 0) (syntax-e x)]
            [(!= (assq (syntax-e x) env) 0) (cdr (assq (syntax-e x) env))]
            [else (syntax-match (binding-of x)
-                   [('substrate-struct _ _ _ ()) x]
+                   [('substrate-struct _ _ _ () . _) x]
                    [('substrate-typedef u) (parsed-type (syntax->datum u))]
                    [_ `(other ,t)])])]
     [('ptr u) `(ptr ,(type-of u env))]
@@ -46,7 +46,7 @@
     [('quote u) (parsed-type (syntax->datum u))]
     [((? identifier? h) a ...)
      (syntax-match (binding-of h)
-       [('substrate-struct _ _ _ (p ...))
+       [('substrate-struct _ _ _ (p ...) . _)
         (if (and (pair? p) (== (length p) (length a))) `(,h ,@(for/list ([u a]) (type-of u env))) `(other ,t))]
        [_ `(other ,t)])]
     [_ `(other ,t)]))
@@ -62,6 +62,6 @@
   (cond [(and (symbol? d) (!= (memq d scalars) 0)) d]
         [(and (pair? d) (!= (memq (car d) '(ptr slice)) 0)) `(,(car d) ,(parsed-type (cadr d)))]
         [(and (pair? d) (== (car d) 'array)) `(array ,(parsed-type (cadr d)) ,(caddr d))]
-        [(and (pair? d) (== (car d) 'struct) (null? (cdddr d))) (name-identifier (cadr d))]
+        [(and (pair? d) (memq (car d) '(struct enum)) (null? (cdddr d))) (name-identifier (cadr d))]
         [(and (pair? d) (== (car d) 'struct)) `(,(name-identifier (cadr d)) ,@(for/list ([a (cadddr d)]) (parsed-type a)))]
         [else `(other ,d)]))

package/std/package/hash.sub

@@ -20,7 +20,7 @@
 
 (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)]
-        [ok #t] [me (cast (ptr waiting) (arena-alloc a (sizeof waiting)))])
+        [ok #t] [me (new a waiting)])
     (when (< (fs-real-path given (& dir) (& why)) 0) (return (cannot! err why)))
     (while (and (!= o 0) (!= (-> o dir) dir)) (set! o (-> o next)))
     (when (!= o 0)

package/std/package/manifest.sub

@@ -59,8 +59,7 @@
   (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))
+        (set! found (copy a d))
         (break))
       (set! d (if (root-path? d) "" (parent-of d))))
     found))
@@ -190,7 +189,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 +197,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 +209,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 +235,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 +252,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 +271,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 +301,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)
@@ -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/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

@@ -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)))
 
@@ -110,9 +107,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 +157,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,8 +19,8 @@
     (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))))
@@ -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)
@@ -132,11 +132,11 @@
 
 (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)
+    (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) (< (fs-remove out #t (& why)) 0)) (throw site-failed 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/test/compare.sub

@@ -23,8 +23,7 @@
         (begin
           (for ([i u32 0]) (< i n) (+= i 1) (diff-line! b 1 (@ xs i)))
           (for ([j u32 0]) (< j m) (+= j 1) (diff-line! b 2 (@ ys j))))
-        (let ([t (cast (ptr u32) (calloc (* (+ n 1) (+ m 1)) 4))] [w (+ m 1)]
-              [kinds (cast (ptr u8) (malloc (+ n m)))] [texts (cast (ptr string) (malloc (* (+ n m) (sizeof string))))]
+        (let ([t (new 0 u32 (* (+ n 1) (+ m 1)))] [w (+ m 1)] [kinds (new 0 u8 (+ n m))] [texts (new 0 string (+ n m))]
               [k u32 0] [i u32 0] [j u32 0] [skipped #f])
           (for ([a u32 n]) (> a 0) (-= a 1)
             (for ([c u32 m]) (> c 0) (-= c 1)
@@ -55,13 +54,13 @@
                   (set! skipped #f)
                   (diff-line! b (@ kinds p) (@ texts p)))
                 (set! skipped #t)))
-          (free (cast (ptr u8) t))
-          (free kinds)
-          (free (cast (ptr u8) texts))))
-    (free (cast (ptr u8) (-> xs items)))
-    (free (cast (ptr u8) (-> ys items)))))
+          (free (-> t items))
+          (free (-> kinds items))
+          (free (-> texts items))))
+    (free (-> xs items))
+    (free (-> ys items))))
 
-(define (changed-near? [kinds (ptr u8)] [k u32] [p u32]) -> bool
+(define (changed-near? [kinds (slice u8)] [k u32] [p u32]) -> bool
   (for ([q u32 (if (> p 2) (- p 2) 0)]) (and (< q k) (<= q (+ p 2))) (+= q 1)
     (when (!= (@ kinds q) 0) (return #t)))
   #f)
@@ -75,11 +74,11 @@
   (let ([n u32 0] [start u32 0] [k u32 0])
     (for ([i u32 0]) (< i (-> text length)) (+= i 1) (when (== (@ text i) 10) (+= n 1)))
     (when (and (> (-> text length) 0) (!= (@ text (- (-> text length) 1)) 10)) (+= n 1))
-    (let ([out (cast (ptr string) (malloc (* (+ n 1) (sizeof string))))])
+    (let ([out (new 0 string (+ n 1))])
       (for ([i u32 0]) (<= i (-> text length)) (+= i 1)
         (when (or (== i (-> text length)) (== (@ text i) 10))
           (when (or (< start i) (< i (-> text length)))
             (set! (@ out k) (slice text start i))
             (+= k 1))
           (set! start (+ i 1))))
-      (slice out k))))
+      (slice out 0 k))))

package/std/test/page.sub

@@ -78,7 +78,7 @@
     (let ([why string])
       (unless (devtools-connect (& connection) address heard 0 (& why)) (throw page-failed why))
       (set! connected #t)))
-  (let ([b (cast (ptr page) (calloc 1 (sizeof page)))])
+  (let ([b (new 0 page)])
     (+= opened 1)
     (set! (-> b site) (kept (absolute dir)))
     (buffer-add-u32! (& pages) (cast u32 b))

package/std/test/run.sub

@@ -38,7 +38,7 @@
     g))
 
 (define (host-in [dir string] [env (slice string)] [g (ptr grants)] [args (slice string)] [input (slice u8)]) -> ran
-  (program-in dir (joined-path (root) "substrate/host/subhost.mjs") env
+  (program-in dir (toolchain-host) env
               (grants-arguments g (@ args 0) (slice args 1 (-> args length))) input))
 
 (define (sub-in [dir string] [clauses (slice (slice string))] [env (slice string)] [args (slice string)]

package/std/test/session.sub

@@ -20,7 +20,6 @@
 (define (run-session [file string])
   (let ([map (string->datum (setting "SUBSTRATE_MODULE_MAP"))])
     (set-toolchain-directory! (string->datum (setting "SUBSTRATE_TOOLCHAIN")))
-    (install-core!)
     (set-module-map-text! (file-text map) map)
     (set-cache-directory! (string->datum (setting "SUBSTRATE_CACHE")))
     (set-display-directory! (string->datum (parent-of file)))