substrate-lang 0.9.2 → 0.9.4

package/build/compiler/program

@@ -1,20 +1,21 @@
-substrate.b31300129ffb@0+0
-writer.b698107b491f@0+0
-syntax.500cf1bcecd4@0+0
-path.ec5532669c81@0+0
-fs.3f7cf768e7ed@0+0
-reader.f4378a1f91d1@0+0
-roots.02808ca2c6a7@0+0
-running.7f03ff780e03@0+0
-core.11abd90bead5@0+0
-ops.a5b9269c5240@0+0
-checker.343075746d8c@0+0
-leb128.0d2a247f239f@0+0
-binary.5d81a93450b2@0+0
-serialize.f4354af92feb@0+0
-compile.2db0f824839f@0+0
-link.3c4158bb6ba3@0+0
-macros.6f0e1a78d640@0+0
-expander.c0f36d0bd5fc@0+0
-prune.f800615ca8cc@0+0
-main.cf521803fc5e@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.b31300129ffb@0+0
-process.94378bb2ecf2@0+0
-path.ec5532669c81@0+0
-path.b98f74b36b19@0+0
-fs.3f7cf768e7ed@0+0
-common.9ea008df47e6@0+0
-grants.e7dc20c93375@0+0
-writer.b698107b491f@0+0
-syntax.500cf1bcecd4@0+0
-reader.f4378a1f91d1@0+0
-roots.02808ca2c6a7@0+0
-read.4b71de2f3337@0+0
-manifest.0c0fe02b1e58@0+0
-git.c47e41fed371@0+0
-files.25d3fe28ff57@0+0
-sha256.92185201fb4b@0+0
-hash.75dc86b3dd19@0+0
-store.128b4d772823@0+0
-map.b767b94ffe7f@0+0
-env.d4a2d3ca5408@0+0
-events.ee8945a7ea00@0+0
-build.3a016536f5a5@0+0
-pack.a62f186e997c@0+0
-site.81b7f3938874@0+0
-site.b678ce0b53b9@0+0
-fetch.22f5c88f8a7b@0+0
-stream.d95d09173ea2@0+0
-worker.5ced1d8ab0d4@0+0
-deflate.67457f2269ae@0+0
-inflate.16c735654147@0+0
-gzip.0bacbb40f6e2@0+0
-tar.9c01735ea170@0+0
-fetch.59ad8bf17eeb@0+0
-doc.49b234ac4521@0+0
-html.a860b2ff2c4e@0+0
-html.1ab670c5f861@0+0
-text.ca2b0668e319@0+0
-root.5a3e4a594d25@0+0
-doc.e0af22e9d586@0+0
-timer.21d74714d40b@0+0
-chromium.0cdcaad35704@0+0
-test.eed7cfa3264c@0+0
-utf8.b61525c6fb12@0+0
-json.74966c67a96d@0+0
-sha512.bf0d4c469a96@0+0
-base64.fc39f9b2a664@0+0
-upgrade.61c36d2a50cf@0+0
-sub.84126bd636af@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.2",
+  "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)

package/std/crypto/sha256.sub

@@ -1,110 +1,4 @@
-;; SHA-256 (FIPS 180-4), over bytes added in pieces or given at once.
-(provide sha256 sha256-init! sha256-add! sha256-end! sha256-of)
+;; SHA-256 (FIPS 180-4), over bytes added in pieces or given at once. It is defined in compiler/sha256.sub.
+(require-unqualified sha256 compiler/sha256)
 
-(struct sha256 [state (array u32 8)] [block (array u8 64)] [filled u32] [length u64])
-
-(define k (array u32 64)
-  (array-of u32 #x428a2f98 #x71374491 #xb5c0fbcf #xe9b5dba5 #x3956c25b #x59f111f1 #x923f82a4 #xab1c5ed5
-               #xd807aa98 #x12835b01 #x243185be #x550c7dc3 #x72be5d74 #x80deb1fe #x9bdc06a7 #xc19bf174
-               #xe49b69c1 #xefbe4786 #x0fc19dc6 #x240ca1cc #x2de92c6f #x4a7484aa #x5cb0a9dc #x76f988da
-               #x983e5152 #xa831c66d #xb00327c8 #xbf597fc7 #xc6e00bf3 #xd5a79147 #x06ca6351 #x14292967
-               #x27b70a85 #x2e1b2138 #x4d2c6dfc #x53380d13 #x650a7354 #x766a0abb #x81c2c92e #x92722c85
-               #xa2bfe8a1 #xa81a664b #xc24b8b70 #xc76c51a3 #xd192e819 #xd6990624 #xf40e3585 #x106aa070
-               #x19a4c116 #x1e376c08 #x2748774c #x34b0bcb5 #x391c0cb3 #x4ed8aa4a #x5b9cca4f #x682e6ff3
-               #x748f82ee #x78a5636f #x84c87814 #x8cc70208 #x90befffa #xa4506ceb #xbef9a3f7 #xc67178f2))
-
-(define (rotr [x u32] [n u32]) #:inline -> u32 (bit-or (>> x n) (<< x (- 32 n))))
-
-(define (word [p (ptr u8)]) #:inline -> u32
-  (bit-or (<< (cast u32 (@ p 0)) 24) (<< (cast u32 (@ p 1)) 16) (<< (cast u32 (@ p 2)) 8) (cast u32 (@ p 3))))
-
-(define (compress! [s (ptr sha256)] [p (ptr u8)])
-  (let ([w (array u32 64)]
-        [a (@ (-> s state) 0)] [b (@ (-> s state) 1)] [c (@ (-> s state) 2)] [d (@ (-> s state) 3)]
-        [e (@ (-> s state) 4)] [f (@ (-> s state) 5)] [g (@ (-> s state) 6)] [hh (@ (-> s state) 7)])
-    (for ([i u32 0]) (< i 16) (+= i 1) (set! (@ w i) (word (+ p (* i 4)))))
-    (for ([i u32 16]) (< i 64) (+= i 1)
-      (let ([x (@ w (- i 15))] [y (@ w (- i 2))])
-        (set! (@ w i) (+ (@ w (- i 16)) (bit-xor (rotr x 7) (rotr x 18) (>> x 3)) (@ w (- i 7))
-                         (bit-xor (rotr y 17) (rotr y 19) (>> y 10))))))
-    (for ([i u32 0]) (< i 64) (+= i 1)
-      (let* ([t1 (+ hh (bit-xor (rotr e 6) (rotr e 11) (rotr e 25)) (bit-xor (bit-and e f) (bit-and (bit-not e) g))
-                    (@ k i) (@ w i))]
-             [t2 (+ (bit-xor (rotr a 2) (rotr a 13) (rotr a 22)) (bit-xor (bit-and a b) (bit-and a c) (bit-and b c)))])
-        (set! hh g)
-        (set! g f)
-        (set! f e)
-        (set! e (+ d t1))
-        (set! d c)
-        (set! c b)
-        (set! b a)
-        (set! a (+ t1 t2))))
-    (+= (@ (-> s state) 0) a)
-    (+= (@ (-> s state) 1) b)
-    (+= (@ (-> s state) 2) c)
-    (+= (@ (-> s state) 3) d)
-    (+= (@ (-> s state) 4) e)
-    (+= (@ (-> s state) 5) f)
-    (+= (@ (-> s state) 6) g)
-    (+= (@ (-> s state) 7) hh)))
-
-(define (sha256-init! [s (ptr sha256)])
-  (set! (@ (-> s state) 0) #x6a09e667)
-  (set! (@ (-> s state) 1) #xbb67ae85)
-  (set! (@ (-> s state) 2) #x3c6ef372)
-  (set! (@ (-> s state) 3) #xa54ff53a)
-  (set! (@ (-> s state) 4) #x510e527f)
-  (set! (@ (-> s state) 5) #x9b05688c)
-  (set! (@ (-> s state) 6) #x1f83d9ab)
-  (set! (@ (-> s state) 7) #x5be0cd19)
-  (set! (-> s filled) 0)
-  (set! (-> s length) 0))
-
-(define (sha256-add! [s (ptr sha256)] [b (slice u8)])
-  (let ([p (-> b items)] [n (-> b length)] [i u32 0])
-    (+= (-> s length) (cast u64 n))
-    (when (> (-> s filled) 0)
-      (while (and (< i n) (< (-> s filled) 64))
-        (set! (@ (-> s block) (-> s filled)) (@ p i))
-        (+= (-> s filled) 1)
-        (+= i 1))
-      (when (== (-> s filled) 64)
-        (compress! s (-> s block))
-        (set! (-> s filled) 0)))
-    (while (<= (+ i 64) n)
-      (compress! s (+ p i))
-      (+= i 64))
-    (while (< i n)
-      (set! (@ (-> s block) (-> s filled)) (@ p i))
-      (+= (-> s filled) 1)
-      (+= i 1))))
-
-;; into takes the 32 bytes of the digest.
-(define (sha256-end! [s (ptr sha256)] [into (slice u8)])
-  (let ([bits (* (-> s length) 8)])
-    (set! (@ (-> s block) (-> s filled)) 128)
-    (+= (-> s filled) 1)
-    (when (> (-> s filled) 56)
-      (while (< (-> s filled) 64)
-        (set! (@ (-> s block) (-> s filled)) 0)
-        (+= (-> s filled) 1))
-      (compress! s (-> s block))
-      (set! (-> s filled) 0))
-    (while (< (-> s filled) 56)
-      (set! (@ (-> s block) (-> s filled)) 0)
-      (+= (-> s filled) 1))
-    (for ([i u32 0]) (< i 8) (+= i 1)
-      (set! (@ (-> s block) (+ 56 i)) (cast u8 (>> bits (* 8 (- 7 i))))))
-    (compress! s (-> s block))
-    (for ([i u32 0]) (< i 8) (+= i 1)
-      (let ([h (@ (-> s state) i)])
-        (set! (@ into (* i 4)) (cast u8 (>> h 24)))
-        (set! (@ into (+ (* i 4) 1)) (cast u8 (>> h 16)))
-        (set! (@ into (+ (* i 4) 2)) (cast u8 (>> h 8)))
-        (set! (@ into (+ (* i 4) 3)) (cast u8 h))))))
-
-(define (sha256-of [b (slice u8)] [into (slice u8)])
-  (let ([s sha256])
-    (sha256-init! (& s))
-    (sha256-add! (& s) b)
-    (sha256-end! (& s) into)))
+(provide (all-from-out sha256))