substrate-lang 0.9.3 → 0.10.0

package/substrate/compiler/serialize.sub

@@ -8,7 +8,7 @@
         [atoms (ptr hash-table)] [pairs (ptr hash-table)] [scopes (ptr hash-table)] [table datum])
 
 (define (make-serializer) -> (ptr serializer)
-  (let ([s (cast (ptr serializer) (arena-alloc (current-arena) (sizeof serializer)))])
+  (let ([s (new (current-arena) serializer)])
     (set! (-> s out) (make-buffer))
     (set! (-> s count) 0)
     (set! (-> s shared) (make-table))
@@ -20,11 +20,11 @@
     s))
 
 (define (scope-index! [s (ptr serializer)] [sc u32]) -> u32
-  (let ([known (hash-ref (-> s scopes) (+ (cast u64 sc) 1))])
+  (let ([known (hash-find (-> s scopes) (+ (cast u64 sc) 1))])
     (if (!= known 0)
-        (- known 1)
+        (@ known)
         (let ([i (-> (-> s scopes) count)])
-          (hash-set! (-> s scopes) (+ (cast u64 sc) 1) (+ i 1))
+          (hash-set! (-> s scopes) (+ (cast u64 sc) 1) i)
           (set! (-> s table) (cons (make-integer sc) (-> s table)))
           i))))
 
@@ -33,16 +33,23 @@
 (define (added! [s (ptr serializer)] [t (ptr hash-table)] [key u64]) -> u32
   (let ([i (-> s count)])
     (+= (-> s count) 1)
-    (hash-set! t key (+ i 1))
+    (hash-set! t key i)
     i))
 
-(define (shared-index [s (ptr serializer)] [key datum]) -> u32
-  (let ([i (datum-get (-> s shared) key)]) (if (== i 0) 0 (+ (cast u32 (integer-value i)) 1))))
+(struct shared-entry [key datum] [index u32] [next (ptr shared-entry)])
+
+(define (shared-find [s (ptr serializer)] [key datum]) -> (ptr u32)
+  (let ([e (cast (ptr shared-entry) (hash-ref (-> s shared) (datum-hash key)))])
+    (while (!= e 0)
+      (when (equal? (-> e key) key) (return (& (-> e index))))
+      (set! e (-> e next)))
+    0))
 
 (define (shared-added! [s (ptr serializer)] [key datum]) -> u32
-  (let ([i (-> s count)])
+  (let* ([t (-> s shared)] [h (datum-hash key)] [i (-> s count)]
+         [e (new (-> t arena) (shared-entry #:key key #:index i #:next (cast (ptr shared-entry) (hash-ref t h))))])
+    (hash-set! t h (cast u32 e))
     (+= (-> s count) 1)
-    (datum-put! (-> s shared) key (make-integer i))
     i))
 
 (define (bytes! [p (ptr buffer)] [b (slice u8)])
@@ -52,70 +59,70 @@
 (define (small [n i64]) -> datum (make-integer n))
 
 (define (serialize! [s (ptr serializer)] [d datum]) -> u32
-  (let ([p (& (-> s out))] [i u32 0])
+  (let ([p (& (-> s out))] [known (ptr u32) 0])
     (cond
       [(== d '#f)
-       (set! i (shared-index s `(0)))
-       (if (!= i 0) (- i 1) (begin (buffer-add-byte! p 0) (shared-added! s `(0))))]
+       (set! known (shared-find s `(0)))
+       (if (!= known 0) (@ known) (begin (buffer-add-byte! p 0) (shared-added! s `(0))))]
       [(fixnum? d)
        (let ([key (+ (cast u64 (integer-value d)) 1099511627776)])
-         (set! i (hash-ref (-> s fixnums) key))
-         (if (!= i 0)
-             (- i 1)
+         (set! known (hash-find (-> s fixnums) key))
+         (if (!= known 0)
+             (@ known)
              (begin (buffer-add-byte! p 1) (write-sleb p (integer-value d)) (added! s (-> s fixnums) key))))]
       [(integer? d)
        (let* ([negative (integer-negative? d)] [v (integer-value d)]
               [magnitude (if negative (- 0 v) v)]
               [key `(10 ,(small negative) ,(make-unsigned-integer (cast u64 magnitude)))])
-         (set! i (shared-index s key))
-         (if (!= i 0)
-             (- i 1)
+         (set! known (shared-find s key))
+         (if (!= known 0)
+             (@ known)
              (begin (buffer-add-byte! p 10)
                     (buffer-add-byte! p negative)
                     (for ([k u32 0]) (< k 8) (+= k 1)
                       (buffer-add-byte! p (cast i32 (bit-and (>> (cast u64 magnitude) (* 8 k)) 255))))
                     (shared-added! s key))))]
       [(== d (boolean #t))
-       (set! i (shared-index s `(2)))
-       (if (!= i 0) (- i 1) (begin (buffer-add-byte! p 2) (shared-added! s `(2))))]
+       (set! known (shared-find s `(2)))
+       (if (!= known 0) (@ known) (begin (buffer-add-byte! p 2) (shared-added! s `(2))))]
       [(null? d)
-       (set! i (shared-index s `(3)))
-       (if (!= i 0) (- i 1) (begin (buffer-add-byte! p 3) (shared-added! s `(3))))]
+       (set! known (shared-find s `(3)))
+       (if (!= known 0) (@ known) (begin (buffer-add-byte! p 3) (shared-added! s `(3))))]
       [(char? d)
        (let ([key `(4 ,d)])
-         (set! i (shared-index s key))
-         (if (!= i 0)
-             (- i 1)
+         (set! known (shared-find s key))
+         (if (!= known 0)
+             (@ known)
              (begin (buffer-add-byte! p 4) (write-uleb p (char->integer d)) (shared-added! s key))))]
       [(pair? d) (serialize-list! s d)]
       [(symbol? d)
-       (set! i (hash-ref (-> s atoms) (cast u64 d)))
-       (if (!= i 0)
-           (- i 1)
+       (set! known (hash-find (-> s atoms) (cast u64 d)))
+       (if (!= known 0)
+           (@ known)
            (begin (buffer-add-byte! p 6) (bytes! p (cast (slice u8) (symbol->string d))) (added! s (-> s atoms) (cast u64 d))))]
       [(string? d)
        (let ([key `(7 ,d)])
-         (set! i (shared-index s key))
-         (if (!= i 0)
-             (- i 1)
+         (set! known (shared-find s key))
+         (if (!= known 0)
+             (@ known)
              (begin (buffer-add-byte! p 7) (bytes! p (cast (slice u8) (datum->string d))) (shared-added! s key))))]
       [(bytes? d)
        (let ([key `(14 ,d)])
-         (set! i (shared-index s key))
-         (if (!= i 0)
-             (- i 1)
+         (set! known (shared-find s key))
+         (if (!= known 0)
+             (@ known)
              (begin (buffer-add-byte! p 14) (bytes! p (datum->bytes d)) (shared-added! s key))))]
       [(keyword? d)
-       (set! i (hash-ref (-> s atoms) (cast u64 d)))
-       (if (!= i 0)
-           (- i 1)
+       (set! known (hash-find (-> s atoms) (cast u64 d)))
+       (if (!= known 0)
+           (@ known)
            (begin (buffer-add-byte! p 13) (bytes! p (cast (slice u8) (keyword->string d))) (added! s (-> s atoms) (cast u64 d))))]
       [(syntax? d) (serialize-syntax! s d)]
       [(flonum? d)
        (let* ([bits (f64-bits (flonum-value d))] [key `(11 ,(make-integer bits))])
-         (set! i (shared-index s key))
-         (if (!= i 0)
-             (- i 1)
+         (set! known (shared-find s key))
+         (if (!= known 0)
+             (@ known)
              (begin (buffer-add-byte! p 11)
                     (for ([k u32 0]) (< k 8) (+= k 1)
                       (buffer-add-byte! p (cast i32 (bit-and (>> (cast u64 bits) (* 8 k)) 255))))
@@ -123,7 +130,7 @@
       [else (raise-compile-error 0 (format-message "internal: serialize: cannot quote ~s" (cons d nil))) 0])))
 
 (define (serialize-list! [s (ptr serializer)] [d datum]) -> u32
-  (let ([cars nil] [l d] [b u32 0] [key u64 0] [i u32 0] [p (& (-> s out))])
+  (let ([cars nil] [l d] [b u32 0] [key u64 0] [known (ptr u32) 0] [p (& (-> s out))])
     (while (pair? l)
       (set! cars (cons (make-integer (serialize! s (car l))) cars))
       (set! l (cdr l)))
@@ -131,9 +138,9 @@
     (while (pair? cars)
       (let ([a (cast u32 (integer-value (car cars)))])
         (set! key (bit-or (<< (+ (cast u64 a) 1) 32) b))
-        (set! i (hash-ref (-> s pairs) key))
-        (set! b (if (!= i 0)
-                    (- i 1)
+        (set! known (hash-find (-> s pairs) key))
+        (set! b (if (!= known 0)
+                    (@ known)
                     (begin (buffer-add-byte! p 5) (write-uleb p a) (write-uleb p b) (added! s (-> s pairs) key)))))
       (set! cars (cdr cars)))
     b))
@@ -144,10 +151,10 @@
          [l (serialize-srcloc! s (syntax-srcloc d))]
          [r (serialize! s (syntax-props d))]
          [key `(8 ,(small e) ,(small sc) ,(small l) ,(small r))]
-         [i (shared-index s key)]
+         [known (shared-find s key)]
          [p (& (-> s out))])
-    (if (!= i 0)
-        (- i 1)
+    (if (!= known 0)
+        (@ known)
         (begin (buffer-add-byte! p 8) (write-uleb p e) (write-uleb p sc) (write-uleb p l) (write-uleb p r)
                (shared-added! s key)))))
 
@@ -162,10 +169,10 @@
       (serialize! s 0)
       (let* ([src (serialize! s (-> l source))]
              [key `(9 ,(small src) ,(small (-> l line)) ,(small (-> l col)) ,(small (-> l pos)) ,(small (-> l span)))]
-             [i (shared-index s key)]
+             [known (shared-find s key)]
              [p (& (-> s out))])
-        (if (!= i 0)
-            (- i 1)
+        (if (!= known 0)
+            (@ known)
             (begin (buffer-add-byte! p 9)
                    (write-uleb p src)
                    (write-sleb p (-> l line))

package/substrate/compiler/substrate.sub

@@ -1,6 +1,6 @@
 ;; Substrate in one module: the language, its runtime and its library.
 
-(provide define struct union variant match exception throw try lambda inst typedef const let let* set!
+(provide define struct union variant enum match exception throw try lambda typedef const let let* set!
          if return values import supply
          #%datum #%top-interaction #%module-begin
          when unless cond case while for break continue rethrow and or not cast sizeof offsetof array-of slice @ & ->
@@ -12,12 +12,15 @@
          printf print-bytes
          output-to! test expect expect-equal test-failed test-skipped
          buffer-add-entries! entry-strings
+         error error-fail! error-text error-free! host-failed!
+         error-missing error-unreachable error-refused error-timeout error-invalid error-aborted error-denied
+         error-in-use error-other error-not-granted error-exists
          sqrt fabs floor ceil trunc nearbyint copysign sqrtf fabsf floorf ceilf truncf nearbyintf copysignf
          malloc calloc realloc free try-malloc try-calloc try-realloc memcpy memset memcmp
-         arena make-arena arena-alloc arena-start! arena-free new
+         arena make-arena arena-alloc arena-start! arena-free new copy
          buffer make-buffer buffer-add! buffer-add-byte! buffer-add-string! buffer-add-utf-8! buffer-add-u32! buffer-add-f32!
          buffer-bytes buffer-string
-         buffer-reserve buffer-free! buffer-trim! hash-bytes hash-table hash-ref hash-set! hash-clear! hash-free!
+         buffer-reserve buffer-free! buffer-trim! hash-bytes hash-table hash-find hash-ref hash-set! hash-clear! hash-free!
          string-copy
          f64-bits bits-f64 f32-bits digit-value digits? digits-integer read-decimal decimal-flonum shortest-digits
          write-digits write-flonum write-string)
@@ -25,9 +28,9 @@
 ;; ---- the forms ----
 
 (define-syntax forms (quote-syntax (#%form forms)))
-(forms #%module-begin #%top-interaction define struct union variant match exception
-       throw try lambda inst substrate-struct-check typedef const let let* #%datum when unless cond case array-of slice
-       while for cast sizeof offsetof -> & set! @ break continue rethrow new printf test expect expect-equal
+(forms #%module-begin #%top-interaction define struct union variant enum match exception
+       throw try lambda substrate-struct-check typedef const let let* #%datum when unless cond case array-of slice
+       while for cast sizeof offsetof -> & set! @ break continue rethrow new copy printf test expect expect-equal
        + - * / % == != < <= > >= and or not bit-and bit-or bit-xor bit-not << >>
        += -= *= /= %= <<= >>= bit-and= bit-or= bit-xor=)
 
@@ -44,6 +47,7 @@
     (constant (const NAME TYPE VALUE))
     (type (struct NAME FIELD ...))
     (type (variant NAME CASE ...))
+    (type (enum NAME CASE ...))
     (type (typedef NAME TYPE))
     (exception (exception NAME TYPE ...))
     (macro (define-syntax NAME _))
@@ -85,10 +89,45 @@
 
 (func (reset-stack!) (set! sp (i32.add stack-base 4194304)))
 
+;; ---- errors ----
+;; A fallible function returns #t, or #f with an error as its last argument. Callers can pass a null pointer (0) when
+;; they do not need the error. They can do the same for an id the function creates. Error codes are defined here.
+
+(const error-missing i32 1)
+(const error-unreachable i32 2)
+(const error-refused i32 3)
+(const error-timeout i32 4)
+(const error-invalid i32 5)
+(const error-aborted i32 6)
+(const error-denied i32 7)
+(const error-in-use i32 8)
+(const error-other i32 9)
+(const error-not-granted i32 10)
+(const error-exists i32 11)
+
+(struct error [code i32] [message buffer])
+
+(define (error-fail! [e (ptr error)] [code i32] [why string]) -> bool
+  (when (!= e 0)
+    (set! (-> e code) code)
+    (set! (-> e message length) 0)
+    (buffer-add-string! (& (-> e message)) why))
+  #f)
+
+(define (error-text [e (ptr error)]) -> string (buffer-string (& (-> e message))))
+
+(define (error-free! [e (ptr error)]) (buffer-free! (& (-> e message))))
+
+(define (host-failed! [why (ptr string)] [e (ptr error)]) -> bool
+  (error-fail! e (failure_code) (@ why))
+  (free (-> why bytes))
+  #f)
+
 ;; ---- the host ----
 ;; Every program may call these host functions without a grant. A call that gives a string or bytes gives them in a
 ;; block from malloc for the caller to free; its pointer is 0 when there are none. A call that can fail stores the
-;; reason at err as such a string, unless err is 0. Lists are slices of strings.
+;; reason at err as such a string, unless err is 0. failure_code then gives the failure's code. Lists are slices of
+;; strings.
 
 (import write "host" "write" (i32 i32 i32 -> i32))
 (import trap "host" "trap" (i32 i32 ->))
@@ -100,6 +139,7 @@
 (import program_modules "host" "program_modules" (i32 -> i32))
 (import module_bytes "host" "module_bytes" (i32 i32 i32 -> i32))
 (import compiled_file "host" "compiled_file" (i32 i32 i32 -> i32))
+(import failure_code "host" "failure_code" (-> i32))
 
 (define (host-write [fd i32] [b (slice u8)]) #:inline -> i32 (write fd (cast i32 (-> b items)) (cast i32 (-> b length))))
 (define (host-trap [s string]) #:inline (trap (cast i32 (-> s bytes)) (cast i32 (-> s length))))
@@ -127,15 +167,15 @@
 ;; is a worker, in which case its parent gets the reason when the worker ends.
 (define (host-exit [code i32] [reason string]) #:inline
   (exit code (cast i32 (-> reason bytes)) (cast i32 (-> reason length))))
-(define (host-instantiate [name string] [code (slice u8)] [imports (slice string)] [compile-time bool] [err (ptr string)])
-  -> i32
-  (let ([b (make-buffer)] [r 0])
+(define (host-instantiate [name string] [code (slice u8)] [imports (slice string)] [compile-time bool]
+                          [err (ptr error)]) -> bool
+  (let ([b (make-buffer)] [r 0] [why string])
     (buffer-add-entries! (& b) imports)
     (set! r (instantiate (cast i32 (-> name bytes)) (cast i32 (-> name length)) (cast i32 (-> code items))
                          (cast i32 (-> code length)) (cast i32 (-> b bytes)) (cast i32 (-> b length)) compile-time
-                         (cast i32 err)))
+                         (cast i32 (& why))))
     (buffer-free! (& b))
-    r))
+    (or (== r 0) (host-failed! (& why) err))))
 (define (host-export-index [instance string] [field string]) #:inline -> i32
   (export_index (cast i32 (-> instance bytes)) (cast i32 (-> instance length)) (cast i32 (-> field bytes))
                 (cast i32 (-> field length))))
@@ -183,10 +223,7 @@
 
 ;; ---- strings and slices ----
 
-(define (string-copy [s string]) -> string
-  (let ([p (cast (ptr u8) (malloc (-> s length)))])
-    (memcpy p (-> s bytes) (-> s length))
-    (cast string (slice p (-> s length)))))
+(define (string-copy [s string]) -> string (copy 0 s))
 
 ;; The checker's code calls these to compare strings by their bytes, and to trap on an index or a part out of range.
 
@@ -588,15 +625,18 @@
 
 (struct hash-table [keys (ptr u64)] [values (ptr u32)] [count u32] [capacity u32] [shift u32] [arena (ptr arena)])
 
-(define (hash-ref [t (ptr hash-table)] [key u64]) #:inline -> u32
+(define (hash-find [t (ptr hash-table)] [key u64]) #:inline -> (ptr u32)
   (if (== (-> t capacity) 0)
       0
       (let* ([keys (-> t keys)] [mask (- (-> t capacity) 1)] [i (cast u32 (>> (* key 11400714819323198485) (-> t shift)))])
         (while (!= (@ keys i) 0)
-          (when (== (@ keys i) key) (return (@ (-> t values) i)))
+          (when (== (@ keys i) key) (return (+ (-> t values) i)))
           (set! i (bit-and (+ i 1) mask)))
         0)))
 
+(define (hash-ref [t (ptr hash-table)] [key u64]) #:inline -> u32
+  (let ([p (hash-find t key)]) (if (== p 0) 0 (@ p))))
+
 (define (hash-set! [t (ptr hash-table)] [key u64] [value u32])
   (when (>= (* 2 (+ (-> t count) 1)) (-> t capacity)) (hash-grow t))
   (let* ([keys (-> t keys)] [mask (- (-> t capacity) 1)] [i (cast u32 (>> (* key 11400714819323198485) (-> t shift)))])
@@ -977,7 +1017,7 @@
   (+ ten-powers (* 2 (+ q 348))))
 
 (define (make-ten-powers) -> (ptr u64)
-  (let* ([t (cast (ptr u64) (malloc 11136))] [limbs (array u64 44)] [x (slice limbs)])
+  (let* ([t (-> (new 0 u64 1392) items)] [limbs (array u64 44)] [x (slice limbs)])
     (memset limbs 0 352)
     (set! (@ x 0) 1)
     (for ([q 0]) (<= q 347) (+= q 1)
@@ -1020,10 +1060,7 @@
           [else (bit-or (<< (cast u64 (+ e2 1075)) 52) (- mant 4503599627370496))])))
 
 ;; A number is 32-bit limbs, least significant first, each in a u64.
-(define (big-new [a (ptr arena)] [len u32]) -> (slice u64)
-  (let ([x (cast (ptr u64) (arena-alloc a (* 8 len)))])
-    (memset x 0 (* 8 len))
-    (slice x len)))
+(define (big-new [a (ptr arena)] [len u32]) -> (slice u64) (new a u64 len))
 
 (define (big-mul-add! [x (slice u64)] [k u64] [c u64])
   (for ([i u32 0]) (< i (-> x length)) (+= i 1)

package/substrate/compiler/syntax.sub

@@ -90,7 +90,7 @@
 (define (in-run-arena?) -> bool (== current (& run-arena)))
 
 (define (begin-module-arena)
-  (let ([m (cast (ptr module-arena) (malloc (sizeof module-arena)))])
+  (let ([m (new 0 module-arena)])
     (set! (-> m arena) (make-arena))
     (set! (-> m outer) innermost)
     (set! innermost m)
@@ -302,7 +302,7 @@
 
 ;; ---- tables in an arena ----
 (define (make-table) -> (ptr hash-table)
-  (let ([t (cast (ptr hash-table) (memset (arena-alloc current (sizeof hash-table)) 0 (sizeof hash-table)))])
+  (let ([t (new current hash-table)])
     (set! (-> t arena) current)
     t))
 
@@ -322,7 +322,7 @@
         (set! (-> e value) value)
         (return))
       (set! e (-> e next)))
-    (set! e (cast (ptr entry) (arena-alloc (-> t arena) (sizeof entry))))
+    (set! e (new (-> t arena) entry))
     (set! (-> e key) key)
     (set! (-> e value) value)
     (set! (-> e next) first)
@@ -341,10 +341,7 @@
 (define symbols hash-table)
 (define keywords hash-table)
 
-(define (kept-text [s string]) -> string
-  (let ([p (cast (ptr u8) (arena-alloc (& run-arena) (-> s length)))])
-    (memcpy p (-> s bytes) (-> s length))
-    (cast string (slice p (-> s length)))))
+(define (kept-text [s string]) -> string (copy (& run-arena) s))
 
 (define (held-text [s string]) -> string
   (let ([p (held-bytes (-> s length))])
@@ -519,11 +516,7 @@
 ;; ---- changes to scopes ----
 
 (define (new-change [sc u32] [kind u32] [next (ptr change)]) -> (ptr change)
-  (let ([c (cast (ptr change) (arena-alloc current (sizeof change)))])
-    (set! (-> c scope) sc)
-    (set! (-> c kind) kind)
-    (set! (-> c next) next)
-    c))
+  (new current (change #:scope sc #:kind kind #:next next)))
 
 (define (changes-add [cs (ptr change)] [sc u32] [kind u32]) -> (ptr change)
   (cond [(== cs 0) (new-change sc kind 0)]
@@ -600,13 +593,7 @@
   (make-cell (syntax e scopes loc props 0)))
 
 (define (make-srcloc [source datum] [line u32] [col u32] [pos u32] [span u32]) -> (ptr srcloc)
-  (let ([l (cast (ptr srcloc) (arena-alloc current (sizeof srcloc)))])
-    (set! (-> l source) source)
-    (set! (-> l line) line)
-    (set! (-> l col) col)
-    (set! (-> l pos) pos)
-    (set! (-> l span) span)
-    l))
+  (new current (srcloc #:source source #:line line #:col col #:pos pos #:span span)))
 
 (define (syntax-e [s datum]) #:copied -> datum
   (match (cell-of s)
@@ -730,7 +717,7 @@
 (define (keep-srcloc [l (ptr srcloc)]) -> (ptr srcloc)
   (if (== l 0)
       0
-      (let ([kept (cast (ptr srcloc) (arena-alloc (& run-arena) (sizeof srcloc)))])
+      (let ([kept (new (& run-arena) srcloc)])
         (set! (@ kept) (@ l))
         kept)))
 
@@ -1098,7 +1085,7 @@
 (define (deserialize [bytes (ptr u8)] [n u32]) -> (ptr datum)
   (set! in-bytes bytes)
   (set! in-at 0)
-  (let* ([count (cast u32 (in-uleb))] [objs (cast (ptr u32) (arena-alloc current (* 4 (+ count 1))))])
+  (let* ([count (cast u32 (in-uleb))] [objs (-> (new current u32 (+ count 1)) items)])
     (for ([i u32 0]) (< i count) (+= i 1) (set! (@ objs i) (in-entry objs)))
     (cast (ptr datum) objs)))
 

package/substrate/host/errors.mjs

@@ -1,7 +1,7 @@
-// The error codes of failed events (events.sub), and errorOf, which gives a JavaScript error its code.
+// The error codes (compiler/substrate.sub), and errorOf, which gives a JavaScript error its code.
 export const errors = {
   missing: 1, unreachable: 2, refused: 3, timeout: 4, invalid: 5, aborted: 6, denied: 7, inUse: 8, other: 9,
-  notGranted: 10,
+  notGranted: 10, exists: 11,
 };
 
 const unreachable = new Set(['ENOTFOUND', 'EAI_AGAIN', 'EHOSTUNREACH', 'ENETUNREACH']);
@@ -13,6 +13,7 @@ export function errorOf(e) {
   if (e.name === 'NotAllowedError' || e.name === 'SecurityError') return errors.denied;
   if (e.code === 'ENOENT' || e.code === 'ENOTDIR') return errors.missing;
   if (e.code === 'EACCES' || e.code === 'EPERM') return errors.denied;
+  if (e.code === 'EEXIST') return errors.exists;
   if (e.code === 'ECONNREFUSED') return errors.refused;
   if (e.code === 'EADDRINUSE') return errors.inUse;
   if (e.code === 'ECONNRESET' || e.code === 'EPIPE') return errors.aborted;

package/substrate/host/events.sub

@@ -1,27 +1,14 @@
 ;; Events from the host. events-take gives the current event's bytes as host calls give them, events-take-text its
 ;; text and events-take-strings its list; event-handler! sets the handler for a source's untagged events, and a tagged
-;; event goes to its tag's handler (compiler/substrate.sub). A failed event's value is one of the error codes here,
-;; and its text is the reason.
+;; event goes to its tag's handler (compiler/substrate.sub). A failed event's value is one of the error codes
+;; (compiler/substrate.sub), and its text is the reason.
 ;; Sources: dom 1, gpu 2, worker 3, audio 4, timer 5, fetch 6, websocket 7, stream 8, net 9, process 10, storage 11,
 ;; location 12, clipboard 13, files 14.
 
-(provide events-take events-take! events-take-text events-take-strings event-handler!
-         error-missing error-unreachable error-refused error-timeout error-invalid error-aborted error-denied
-         error-in-use error-other error-not-granted)
+(provide events-take events-take! events-take-text events-take-strings event-handler!)
 
 (import take "events" "take" (i32 -> i32))
 
-(const error-missing i32 1)
-(const error-unreachable i32 2)
-(const error-refused i32 3)
-(const error-timeout i32 4)
-(const error-invalid i32 5)
-(const error-aborted i32 6)
-(const error-denied i32 7)
-(const error-in-use i32 8)
-(const error-other i32 9)
-(const error-not-granted i32 10)
-
 (define defaults (array handler 64))
 
 (define (by-source [source u32] [kind u32] [id u32] [tag (ptr void)] [value i32])

package/substrate/host/fs.mjs

@@ -1,5 +1,6 @@
 // The host module "fs" (fs.sub), over the files that node/fs.mjs or web/fs.mjs gives.
 import { joined } from './entries.mjs';
+import { errors, errorOf } from './errors.mjs';
 
 const utf8 = new TextEncoder();
 
@@ -22,7 +23,7 @@ export function fsModule(files) {
         return f();
       } catch (e) {
         if (e instanceof WebAssembly.RuntimeError) throw e;
-        caller.fail(err, `${path}: ${e.message}`);
+        caller.fail(err, `${path}: ${e.message}`, errorOf(e));
         return failed;
       }
     };
@@ -31,7 +32,7 @@ export function fsModule(files) {
     const using = (h, err, f, failed = -1) => {
       const open = handles.get(h);
       if (open) return attempt(open.path, err, () => f(open.file), failed);
-      caller.fail(err, `file ${h}: Bad file descriptor`);
+      caller.fail(err, `file ${h}: Bad file descriptor`, errors.invalid);
       return failed;
     };
     const bytesAt = (ptr, len) => caller.memory().subarray(caller.u(ptr), caller.u(ptr) + len);
@@ -81,7 +82,7 @@ export function fsModule(files) {
       file_stream(h, write, start, tag, err) {
         const open = handles.get(h);
         if (!open) {
-          caller.fail(err, `file ${h}: Bad file descriptor`);
+          caller.fail(err, `file ${h}: Bad file descriptor`, errors.invalid);
           return 0;
         }
         handles.delete(h);
@@ -90,7 +91,7 @@ export function fsModule(files) {
         } catch (e) {
           if (e instanceof WebAssembly.RuntimeError) throw e;
           attempt(open.path, 0, () => open.file.close());
-          caller.fail(err, `${open.path}: ${e.message}`);
+          caller.fail(err, `${open.path}: ${e.message}`, errorOf(e));
           return 0;
         }
       },