substrate-lang 0.9.3 → 0.9.4

package/build/compiler/program

@@ -1,21 +1,21 @@
-substrate.4c780d6dd6d4@0+0
-writer.806bc85aa684@0+0
-syntax.9857f6784d63@0+0
-path.dcc4712bcc7b@0+0
-fs.563034be70c3@0+0
-reader.b535e61f99f4@0+0
-roots.6d2942578055@0+0
-running.d73f7826cb74@0+0
-core.fc3dab9d1846@0+0
-ops.b361e858d8e1@0+0
-checker.592d37dcbec9@0+0
-leb128.748b1c37277a@0+0
-binary.3823f89ce414@0+0
-serialize.b2196de75bc8@0+0
-compile.86a2b03b0c9b@0+0
-sha256.5fc9d60f8bb2@0+0
-link.11b643d35670@0+0
-macros.4083601c00db@0+0
-expander.689d326e5a1b@0+0
-prune.d4a3f9834095@0+0
-main.ed62cce43000@0+0
+substrate.728c690187f2@0+0
+writer.550227768eb9@0+0
+syntax.fadc832db29f@0+0
+path.1b5fd988b6f3@0+0
+fs.5017b627cbd2@0+0
+reader.d256e69e09e2@0+0
+roots.e366210c01d6@0+0
+running.b99787c2d180@0+0
+core.0410ffbdc488@0+0
+ops.324f0a665fab@0+0
+checker.2b0ea87ed311@0+0
+leb128.ba77430f659f@0+0
+binary.cdd2ffb408dd@0+0
+serialize.a12536bbbe9a@0+0
+compile.da85f9bc4478@0+0
+sha256.f6c742932dde@0+0
+link.be6e641afa93@0+0
+macros.b695763c0ca3@0+0
+expander.80707e1666d6@0+0
+prune.29dde307bdee@0+0
+main.cbbdf42e34c2@0+0

package/build/sub/program

@@ -1,48 +1,48 @@
-substrate.4c780d6dd6d4@0+0
-process.aea2c88cb7a0@0+0
-path.dcc4712bcc7b@0+0
-path.b7a8e1cf3aaa@0+0
-fs.563034be70c3@0+0
-common.91ddee6b7a67@0+0
-grants.5bf25700d47c@0+0
-writer.806bc85aa684@0+0
-syntax.9857f6784d63@0+0
-reader.b535e61f99f4@0+0
-roots.6d2942578055@0+0
-read.cd1e693f4fb4@0+0
-manifest.cf7471880377@0+0
-git.48aefa1644be@0+0
-files.30e55182c5df@0+0
-sha256.5fc9d60f8bb2@0+0
-hash.3f0d118da63f@0+0
-store.d4e845ff24ac@0+0
-map.dc516eec27ff@0+0
-env.f051f8166526@0+0
-events.f952172735e0@0+0
-build.84ac996eda63@0+0
-pack.55992e8cc09c@0+0
-site.7c6d8c7747af@0+0
-site.81548474c323@0+0
-fetch.097f1cc9502d@0+0
-stream.4c07247477f7@0+0
-worker.f1190de21b21@0+0
-deflate.fc8075e3aed1@0+0
-inflate.8899e0933792@0+0
-gzip.69588e97c35a@0+0
-tar.e482cf873cfc@0+0
-fetch.5d2f427c995e@0+0
-doc.566f9861828e@0+0
-html.c1671a102b4d@0+0
-html.20baa1dc7ca6@0+0
-text.4ab70ac35b5a@0+0
-root.9b713ec588c1@0+0
-doc.0b48bbac404b@0+0
-timer.3809bb17a7a1@0+0
-chromium.e4db7d29897c@0+0
-test.0d9c079bb309@0+0
-utf8.524c475ecd40@0+0
-json.f15a29d99d8d@0+0
-sha512.b988b9dc6114@0+0
-base64.8fba03e1be0a@0+0
-upgrade.18a5aa0dae89@0+0
-sub.b57e17b6876b@0+0
+substrate.728c690187f2@0+0
+process.ca10ac0b8a62@0+0
+path.1b5fd988b6f3@0+0
+path.de22f6659534@0+0
+fs.5017b627cbd2@0+0
+common.997c21b0b8cf@0+0
+grants.cd99dff2854e@0+0
+writer.550227768eb9@0+0
+syntax.fadc832db29f@0+0
+reader.d256e69e09e2@0+0
+roots.e366210c01d6@0+0
+read.279fafcda508@0+0
+manifest.6e014ac19e5d@0+0
+git.1c5791236e35@0+0
+files.1706cc0941c0@0+0
+sha256.f6c742932dde@0+0
+hash.ba8330dad9ff@0+0
+store.c48db3345968@0+0
+map.e582eae03ec2@0+0
+env.861d55fff974@0+0
+events.2c981f6f1ec7@0+0
+build.115aeefc15e8@0+0
+pack.4295e4f5bdbd@0+0
+site.e6e415bc3170@0+0
+site.76aa8286c257@0+0
+fetch.d62aa5fc9623@0+0
+stream.27fd2fe858e1@0+0
+worker.ea1e11f8f5e2@0+0
+deflate.3138a38325a1@0+0
+inflate.3cfa17586072@0+0
+gzip.9ebea150f218@0+0
+tar.692c0e8827cd@0+0
+fetch.b0ce8f8b3da8@0+0
+doc.f18ad14060e9@0+0
+html.3b3c8d7d9971@0+0
+html.0b0362932a75@0+0
+text.8ff142d72fd7@0+0
+root.02141d04d568@0+0
+doc.e3f9a998cd91@0+0
+timer.d3454726b3bf@0+0
+chromium.fc0bfea0fbe6@0+0
+test.1fd2ff8123bf@0+0
+utf8.e82afeb9e953@0+0
+json.af2e0ae20084@0+0
+sha512.9fee24e95460@0+0
+base64.454b045156d2@0+0
+upgrade.2a9219e6a45d@0+0
+sub.c0fb7310de12@0+0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "substrate-lang",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "description": "A Lisp for writing WebAssembly, and the substrate command that builds, runs and tests it",
   "license": "MIT",
   "repository": {

package/std/archive/tar.sub

@@ -2,13 +2,11 @@
 ;; names. tar-next! gives each entry in turn: a file with its bytes, a directory, or another kind, with its path.
 (require-unqualified host/fs)
 
-(provide tar-reader tar-entry tar-reader-init! tar-next! tar-file tar-directory tar-other tar-unpack!)
+(provide tar-reader tar-entry tar-reader-init! tar-next! tar-kind tar-file tar-directory tar-other tar-unpack!)
 
-(const tar-file i32 1)
-(const tar-directory i32 2)
-(const tar-other i32 3)
+(enum tar-kind [tar-file 1] tar-directory tar-other)
 
-(struct tar-entry [kind i32] [path string] [bytes (slice u8)])
+(struct tar-entry [kind tar-kind] [path string] [bytes (slice u8)])
 (struct tar-reader [data (slice u8)] [at u32])
 
 (define (tar-reader-init! [r (ptr tar-reader)] [data (slice u8)])
@@ -36,7 +34,7 @@
         (cond [(== type #\x)
                (unless (pax! a body (& long) (& sized) (& given-size)) (return (bad! err "a pax header is not key=value records")))]
               [(or (== type #\g) (== type #\K)) (begin)]
-              [(== type #\L) (set! long (copied a (until-zero body)))]
+              [(== type #\L) (set! long (cast string (copy a (until-zero body))))]
               [else
                (set! (-> e kind) (cond [(or (== type #\0) (== type 0) (== type #\7)) tar-file]
                                        [(== type #\5) tar-directory]
@@ -91,11 +89,11 @@
   (and (> (-> p length) (-> top length)) (== (slice p 0 (-> top length)) top) (== (@ p (-> top length)) #\/)))
 
 (define (under [a (ptr arena)] [dir string] [p string]) -> string
-  (let ([out (cast (ptr u8) (arena-alloc a (+ (-> dir length) 1 (-> p length))))])
-    (memcpy out (-> dir bytes) (-> dir length))
+  (let ([out (new a u8 (+ (-> dir length) 1 (-> p length)))])
+    (memcpy (-> out items) (-> dir bytes) (-> dir length))
     (set! (@ out (-> dir length)) #\/)
-    (memcpy (+ out (-> dir length) 1) (-> p bytes) (-> p length))
-    (cast string (slice out (+ (-> dir length) 1 (-> p length))))))
+    (memcpy (+ (-> out items) (-> dir length) 1) (-> p bytes) (-> p length))
+    (cast string out)))
 
 (define (up-to-last-slash [p string]) -> string
   (let ([i (-> p length)])
@@ -154,7 +152,7 @@
         (while (and (< eq (- end 1)) (!= (@ body eq) #\=)) (+= eq 1))
         (when (>= eq (- end 1)) (return #f))
         (let ([key (cast string (slice body (+ i 1) eq))] [value (cast string (slice body (+ eq 1) (- end 1)))])
-          (cond [(== key "path") (set! (@ path) (copied a (cast (slice u8) value)))]
+          (cond [(== key "path") (set! (@ path) (copy a value))]
                 [(== key "size")
                  (unless (decimal value size) (return #f))
                  (set! (@ sized) #t)]))
@@ -164,19 +162,14 @@
 (define (header-path [a (ptr arena)] [h (slice u8)]) -> string
   (let ([name (until-zero (slice h 0 100))] [prefix (until-zero (slice h 345 500))])
     (if (and (== (cast string (slice h 257 263)) "ustar\x00;") (> (-> prefix length) 0))
-        (let ([out (cast (ptr u8) (arena-alloc a (+ (-> prefix length) 1 (-> name length))))])
-          (memcpy out (-> prefix items) (-> prefix length))
+        (let ([out (new a u8 (+ (-> prefix length) 1 (-> name length)))])
+          (memcpy (-> out items) (-> prefix items) (-> prefix length))
           (set! (@ out (-> prefix length)) #\/)
-          (memcpy (+ out (-> prefix length) 1) (-> name items) (-> name length))
-          (cast string (slice out (+ (-> prefix length) 1 (-> name length)))))
-        (copied a name))))
+          (memcpy (+ (-> out items) (-> prefix length) 1) (-> name items) (-> name length))
+          (cast string out))
+        (cast string (copy a name)))))
 
 (define (until-zero [s (slice u8)]) -> (slice u8)
   (let ([i u32 0])
     (while (and (< i (-> s length)) (!= (@ s i) 0)) (+= i 1))
     (slice s 0 i)))
-
-(define (copied [a (ptr arena)] [s (slice u8)]) -> string
-  (let ([out (cast (ptr u8) (arena-alloc a (-> s length)))])
-    (memcpy out (-> s items) (-> s length))
-    (cast string (slice out (-> s length)))))

package/std/compress/deflate.sub

@@ -3,12 +3,10 @@
 ;; whichever is shortest. deflate! adds in's compressed form to out: deflate-none may hold some back, deflate-sync sends
 ;; everything and ends at a whole byte, deflate-finish ends the stream. deflater-reset! starts another stream, and
 ;; deflate-alone! compresses bytes as if nothing came before, ending as a sync, so one deflater serves many streams.
-(provide deflater deflater-init! deflater-free! deflater-reset! deflate! deflate-alone! deflate-none deflate-sync
-         deflate-finish)
+(provide deflater deflater-init! deflater-free! deflater-reset! deflate! deflate-alone! deflate-flush deflate-none
+         deflate-sync deflate-finish)
 
-(const deflate-none i32 0)
-(const deflate-sync i32 1)
-(const deflate-finish i32 2)
+(enum deflate-flush deflate-none deflate-sync deflate-finish)
 
 (const wsize u32 32768)
 (const wmask u32 32767)
@@ -155,10 +153,10 @@
     (set! (-> d lazy) (@ settings (+ (* l 4) 1)))
     (set! (-> d nice) (@ settings (+ (* l 4) 2)))
     (set! (-> d chain) (@ settings (+ (* l 4) 3))))
-  (set! (-> d window) (cast (ptr u8) (malloc (+ (* 2 wsize) 272))))
-  (set! (-> d head) (cast (ptr u16) (calloc hash-size 2)))
-  (set! (-> d prev) (cast (ptr u16) (calloc wsize 2)))
-  (set! (-> d syms) (cast (ptr u32) (malloc (* (+ most-symbols 1) 4))))
+  (set! (-> d window) (malloc (+ (* 2 wsize) 272)))
+  (set! (-> d head) (-> (new 0 u16 hash-size) items))
+  (set! (-> d prev) (-> (new 0 u16 wsize) items))
+  (set! (-> d syms) (malloc (* (+ most-symbols 1) (sizeof u32))))
   (set! (-> d strstart) 1)
   (deflater-reset! d))
 
@@ -432,7 +430,7 @@
 ;; ---- matching ----
 
 ;; greedy! takes a match wherever it finds one, and returns #t when it waits for more of the stream.
-(define (greedy! [d (ptr deflater)] [out (ptr buffer)] [in (slice u8)] [at (ptr u32)] [flush i32]) -> bool
+(define (greedy! [d (ptr deflater)] [out (ptr buffer)] [in (slice u8)] [at (ptr u32)] [flush deflate-flush]) -> bool
   (while #t
     (when (< (-> d lookahead) min-lookahead)
       (fill! d in at)
@@ -459,7 +457,7 @@
   #f)
 
 ;; lazy! takes a match only when the next position has none longer.
-(define (lazy! [d (ptr deflater)] [out (ptr buffer)] [in (slice u8)] [at (ptr u32)] [flush i32]) -> bool
+(define (lazy! [d (ptr deflater)] [out (ptr buffer)] [in (slice u8)] [at (ptr u32)] [flush deflate-flush]) -> bool
   (while #t
     (when (< (-> d lookahead) min-lookahead)
       (fill! d in at)
@@ -497,7 +495,7 @@
     (set! (-> d available) #f))
   #f)
 
-(define (deflate! [d (ptr deflater)] [out (ptr buffer)] [in (slice u8)] [flush i32])
+(define (deflate! [d (ptr deflater)] [out (ptr buffer)] [in (slice u8)] [flush deflate-flush])
   (let ([at u32 0])
     (when (if (>= (-> d level) 4) (lazy! d out in (& at) flush) (greedy! d out in (& at) flush)) (return))
     (cond [(== flush deflate-finish)