@shd101wyy/yo 0.1.26 → 0.1.27

package/std/crypto/md5.yo

@@ -8,127 +8,226 @@
 //!
 //! digest := md5_hex(data);  // "5d41402abc4b2a76b9719d911017c592"
 //! ```
-
-{ ArrayList } :: import "../collections/array_list";
-{ hex_encode } :: import "../encoding/hex";
-open import "../string";
-
+{ ArrayList } :: import("../collections/array_list");
+{ hex_encode } :: import("../encoding/hex");
+open(import("../string"));
 // ============================================================================
 // MD5 implementation
 // ============================================================================
-
 _T :: Array(u32, usize(64))(
-  u32(0xd76aa478), u32(0xe8c7b756), u32(0x242070db), u32(0xc1bdceee),
-  u32(0xf57c0faf), u32(0x4787c62a), u32(0xa8304613), u32(0xfd469501),
-  u32(0x698098d8), u32(0x8b44f7af), u32(0xffff5bb1), u32(0x895cd7be),
-  u32(0x6b901122), u32(0xfd987193), u32(0xa679438e), u32(0x49b40821),
-  u32(0xf61e2562), u32(0xc040b340), u32(0x265e5a51), u32(0xe9b6c7aa),
-  u32(0xd62f105d), u32(0x02441453), u32(0xd8a1e681), u32(0xe7d3fbc8),
-  u32(0x21e1cde6), u32(0xc33707d6), u32(0xf4d50d87), u32(0x455a14ed),
-  u32(0xa9e3e905), u32(0xfcefa3f8), u32(0x676f02d9), u32(0x8d2a4c8a),
-  u32(0xfffa3942), u32(0x8771f681), u32(0x6d9d6122), u32(0xfde5380c),
-  u32(0xa4beea44), u32(0x4bdecfa9), u32(0xf6bb4b60), u32(0xbebfbc70),
-  u32(0x289b7ec6), u32(0xeaa127fa), u32(0xd4ef3085), u32(0x04881d05),
-  u32(0xd9d4d039), u32(0xe6db99e5), u32(0x1fa27cf8), u32(0xc4ac5665),
-  u32(0xf4292244), u32(0x432aff97), u32(0xab9423a7), u32(0xfc93a039),
-  u32(0x655b59c3), u32(0x8f0ccc92), u32(0xffeff47d), u32(0x85845dd1),
-  u32(0x6fa87e4f), u32(0xfe2ce6e0), u32(0xa3014314), u32(0x4e0811a1),
-  u32(0xf7537e82), u32(0xbd3af235), u32(0x2ad7d2bb), u32(0xeb86d391)
+  u32(0xd76aa478),
+  u32(0xe8c7b756),
+  u32(0x242070db),
+  u32(0xc1bdceee),
+  u32(0xf57c0faf),
+  u32(0x4787c62a),
+  u32(0xa8304613),
+  u32(0xfd469501),
+  u32(0x698098d8),
+  u32(0x8b44f7af),
+  u32(0xffff5bb1),
+  u32(0x895cd7be),
+  u32(0x6b901122),
+  u32(0xfd987193),
+  u32(0xa679438e),
+  u32(0x49b40821),
+  u32(0xf61e2562),
+  u32(0xc040b340),
+  u32(0x265e5a51),
+  u32(0xe9b6c7aa),
+  u32(0xd62f105d),
+  u32(0x02441453),
+  u32(0xd8a1e681),
+  u32(0xe7d3fbc8),
+  u32(0x21e1cde6),
+  u32(0xc33707d6),
+  u32(0xf4d50d87),
+  u32(0x455a14ed),
+  u32(0xa9e3e905),
+  u32(0xfcefa3f8),
+  u32(0x676f02d9),
+  u32(0x8d2a4c8a),
+  u32(0xfffa3942),
+  u32(0x8771f681),
+  u32(0x6d9d6122),
+  u32(0xfde5380c),
+  u32(0xa4beea44),
+  u32(0x4bdecfa9),
+  u32(0xf6bb4b60),
+  u32(0xbebfbc70),
+  u32(0x289b7ec6),
+  u32(0xeaa127fa),
+  u32(0xd4ef3085),
+  u32(0x04881d05),
+  u32(0xd9d4d039),
+  u32(0xe6db99e5),
+  u32(0x1fa27cf8),
+  u32(0xc4ac5665),
+  u32(0xf4292244),
+  u32(0x432aff97),
+  u32(0xab9423a7),
+  u32(0xfc93a039),
+  u32(0x655b59c3),
+  u32(0x8f0ccc92),
+  u32(0xffeff47d),
+  u32(0x85845dd1),
+  u32(0x6fa87e4f),
+  u32(0xfe2ce6e0),
+  u32(0xa3014314),
+  u32(0x4e0811a1),
+  u32(0xf7537e82),
+  u32(0xbd3af235),
+  u32(0x2ad7d2bb),
+  u32(0xeb86d391)
 );
-
 _S :: Array(u32, usize(64))(
-  u32(7), u32(12), u32(17), u32(22), u32(7), u32(12), u32(17), u32(22),
-  u32(7), u32(12), u32(17), u32(22), u32(7), u32(12), u32(17), u32(22),
-  u32(5),  u32(9), u32(14), u32(20), u32(5),  u32(9), u32(14), u32(20),
-  u32(5),  u32(9), u32(14), u32(20), u32(5),  u32(9), u32(14), u32(20),
-  u32(4), u32(11), u32(16), u32(23), u32(4), u32(11), u32(16), u32(23),
-  u32(4), u32(11), u32(16), u32(23), u32(4), u32(11), u32(16), u32(23),
-  u32(6), u32(10), u32(15), u32(21), u32(6), u32(10), u32(15), u32(21),
-  u32(6), u32(10), u32(15), u32(21), u32(6), u32(10), u32(15), u32(21)
+  u32(7),
+  u32(12),
+  u32(17),
+  u32(22),
+  u32(7),
+  u32(12),
+  u32(17),
+  u32(22),
+  u32(7),
+  u32(12),
+  u32(17),
+  u32(22),
+  u32(7),
+  u32(12),
+  u32(17),
+  u32(22),
+  u32(5),
+  u32(9),
+  u32(14),
+  u32(20),
+  u32(5),
+  u32(9),
+  u32(14),
+  u32(20),
+  u32(5),
+  u32(9),
+  u32(14),
+  u32(20),
+  u32(5),
+  u32(9),
+  u32(14),
+  u32(20),
+  u32(4),
+  u32(11),
+  u32(16),
+  u32(23),
+  u32(4),
+  u32(11),
+  u32(16),
+  u32(23),
+  u32(4),
+  u32(11),
+  u32(16),
+  u32(23),
+  u32(4),
+  u32(11),
+  u32(16),
+  u32(23),
+  u32(6),
+  u32(10),
+  u32(15),
+  u32(21),
+  u32(6),
+  u32(10),
+  u32(15),
+  u32(21),
+  u32(6),
+  u32(10),
+  u32(15),
+  u32(21),
+  u32(6),
+  u32(10),
+  u32(15),
+  u32(21)
 );
-
-_rotl32 :: (fn(x: u32, n: u32) -> u32)(
-  ((x << n) | (x >> (u32(32) - n)))
+_rotl32 :: (fn(x : u32, n : u32) -> u32)(
+  (x << n) | (x >> (u32(32) - n))
 );
-
-_le32 :: (fn(p: *(u8)) -> u32)(
-  ((u32(p.*) | (u32((p &+ usize(1)).*) << u32(8))) |
-  ((u32((p &+ usize(2)).*) << u32(16)) | (u32((p &+ usize(3)).*) << u32(24))))
+_le32 :: (fn(p : *(u8)) -> u32)(
+  (u32(p.*) | (u32((p &+ usize(1)).*) << u32(8))) |
+    ((u32((p &+ usize(2)).*) << u32(16)) | (u32((p &+ usize(3)).*) << u32(24)))
 );
-
-_md5_block :: (fn(block: *(u8), h: *(u32)) -> unit)({
+_md5_block :: (fn(block : *(u8), h : *(u32)) -> unit)({
   a := (h &+ usize(0)).*;
   b := (h &+ usize(1)).*;
   c := (h &+ usize(2)).*;
   d := (h &+ usize(3)).*;
   i := usize(0);
-  while (i < usize(64)), (i = (i + usize(1))), {
+  while(i < usize(64), i = (i + usize(1)), {
     fv := u32(0);
-    g  := usize(0);
+    g := usize(0);
     cond(
       (i < usize(16)) => {
-        fv = ((b & c) | ((~b) & d));
-        g  = i;
+        fv = ((b & c) | ((~(b)) & d));
+        g = i;
       },
       (i < usize(32)) => {
-        fv = ((d & b) | ((~d) & c));
-        g  = (((i * usize(5)) + usize(1)) % usize(16));
+        fv = ((d & b) | ((~(d)) & c));
+        g = (((i * usize(5)) + usize(1)) % usize(16));
       },
       (i < usize(48)) => {
         fv = ((b ^ c) ^ d);
-        g  = (((i * usize(3)) + usize(5)) % usize(16));
+        g = (((i * usize(3)) + usize(5)) % usize(16));
       },
       true => {
-        fv = (c ^ (b | (~d)));
-        g  = ((i * usize(7)) % usize(16));
+        fv = (c ^ (b | (~(d))));
+        g = ((i * usize(7)) % usize(16));
       }
     );
-    fv = (((fv + a) + _T(i)) + _le32((block &+ (g * usize(4)))));
-    a  = d;
-    d  = c;
-    c  = b;
-    b  = (b + _rotl32(fv, _S(i)));
-  };
+    fv = (((fv + a) + _T(i)) + _le32(block &+ (g * usize(4))));
+    a = d;
+    d = c;
+    c = b;
+    b = (b + _rotl32(fv, _S(i)));
+  });
   (h &+ usize(0)).* = ((h &+ usize(0)).* + a);
   (h &+ usize(1)).* = ((h &+ usize(1)).* + b);
   (h &+ usize(2)).* = ((h &+ usize(2)).* + c);
   (h &+ usize(3)).* = ((h &+ usize(3)).* + d);
 });
-
 // Compute an MD5 digest over `data`.
-md5 :: (fn(data: ArrayList(u8)) -> Array(u8, usize(16)))({
+md5 :: (fn(data : ArrayList(u8)) -> Array(u8, usize(16)))({
   h := Array(u32, usize(4))(
-    u32(0x67452301), u32(0xefcdab89), u32(0x98badcfe), u32(0x10325476)
+    u32(0x67452301),
+    u32(0xefcdab89),
+    u32(0x98badcfe),
+    u32(0x10325476)
   );
   h_ptr := &(h(usize(0)));
-  n     := data.len();
+  n := data.len();
   // Process full blocks
   i := usize(0);
-  while ((i + usize(64)) <= n), (i = (i + usize(64))), {
+  while((i + usize(64)) <= n, i = (i + usize(64)), {
     chunk_ptr := (*(u8)(data.ptr().unwrap()) &+ i);
     _md5_block(chunk_ptr, h_ptr);
-  };
+  });
   // Final block(s) with padding
   pad_buf := Array(u8, usize(128)).fill(u8(0));
   pad_ptr := &(pad_buf(usize(0)));
   rem := (n - i);
   j := usize(0);
-  while (j < rem), (j = (j + usize(1))), {
-    (pad_ptr &+ j).* = data.get((i + j)).unwrap();
-  };
+  while(j < rem, j = (j + usize(1)), {
+    (pad_ptr &+ j).* = data.get(i + j).unwrap();
+  });
   (pad_ptr &+ rem).* = u8(0x80);
   cond(
     (rem < usize(56)) => {
       // Length fits in this block
-      bit_len := u64((n * usize(8)));
+      bit_len := u64(n * usize(8));
       (pad_ptr &+ usize(56)).* = u8(bit_len);
-      (pad_ptr &+ usize(57)).* = u8((bit_len >> u64(8)));
-      (pad_ptr &+ usize(58)).* = u8((bit_len >> u64(16)));
-      (pad_ptr &+ usize(59)).* = u8((bit_len >> u64(24)));
-      (pad_ptr &+ usize(60)).* = u8((bit_len >> u64(32)));
-      (pad_ptr &+ usize(61)).* = u8((bit_len >> u64(40)));
-      (pad_ptr &+ usize(62)).* = u8((bit_len >> u64(48)));
-      (pad_ptr &+ usize(63)).* = u8((bit_len >> u64(56)));
+      (pad_ptr &+ usize(57)).* = u8(bit_len >> u64(8));
+      (pad_ptr &+ usize(58)).* = u8(bit_len >> u64(16));
+      (pad_ptr &+ usize(59)).* = u8(bit_len >> u64(24));
+      (pad_ptr &+ usize(60)).* = u8(bit_len >> u64(32));
+      (pad_ptr &+ usize(61)).* = u8(bit_len >> u64(40));
+      (pad_ptr &+ usize(62)).* = u8(bit_len >> u64(48));
+      (pad_ptr &+ usize(63)).* = u8(bit_len >> u64(56));
       _md5_block(pad_ptr, h_ptr);
     },
     true => {
@@ -136,42 +235,39 @@ md5 :: (fn(data: ArrayList(u8)) -> Array(u8, usize(16)))({
       _md5_block(pad_ptr, h_ptr);
       pad2 := Array(u8, usize(64)).fill(u8(0));
       pad2_ptr := &(pad2(usize(0)));
-      bit_len := u64((n * usize(8)));
+      bit_len := u64(n * usize(8));
       (pad2_ptr &+ usize(56)).* = u8(bit_len);
-      (pad2_ptr &+ usize(57)).* = u8((bit_len >> u64(8)));
-      (pad2_ptr &+ usize(58)).* = u8((bit_len >> u64(16)));
-      (pad2_ptr &+ usize(59)).* = u8((bit_len >> u64(24)));
-      (pad2_ptr &+ usize(60)).* = u8((bit_len >> u64(32)));
-      (pad2_ptr &+ usize(61)).* = u8((bit_len >> u64(40)));
-      (pad2_ptr &+ usize(62)).* = u8((bit_len >> u64(48)));
-      (pad2_ptr &+ usize(63)).* = u8((bit_len >> u64(56)));
+      (pad2_ptr &+ usize(57)).* = u8(bit_len >> u64(8));
+      (pad2_ptr &+ usize(58)).* = u8(bit_len >> u64(16));
+      (pad2_ptr &+ usize(59)).* = u8(bit_len >> u64(24));
+      (pad2_ptr &+ usize(60)).* = u8(bit_len >> u64(32));
+      (pad2_ptr &+ usize(61)).* = u8(bit_len >> u64(40));
+      (pad2_ptr &+ usize(62)).* = u8(bit_len >> u64(48));
+      (pad2_ptr &+ usize(63)).* = u8(bit_len >> u64(56));
       _md5_block(pad2_ptr, h_ptr);
     }
   );
   // Output little-endian digest
   digest := Array(u8, usize(16)).fill(u8(0));
   k := usize(0);
-  while (k < usize(4)), (k = (k + usize(1))), {
+  while(k < usize(4), k = (k + usize(1)), {
     w := h(k);
-    digest((k * usize(4)))                 = u8(w);
-    digest(((k * usize(4)) + usize(1)))    = u8((w >> u32(8)));
-    digest(((k * usize(4)) + usize(2)))    = u8((w >> u32(16)));
-    digest(((k * usize(4)) + usize(3)))    = u8((w >> u32(24)));
-  };
+    digest(k * usize(4)) = u8(w);
+    digest((k * usize(4)) + usize(1)) = u8(w >> u32(8));
+    digest((k * usize(4)) + usize(2)) = u8(w >> u32(16));
+    digest((k * usize(4)) + usize(3)) = u8(w >> u32(24));
+  });
   digest
 });
-
-export md5;
-
+export(md5);
 // Return the 32-character lowercase hex MD5 digest.
-md5_hex :: (fn(data: ArrayList(u8)) -> String)({
+md5_hex :: (fn(data : ArrayList(u8)) -> String)({
   digest := md5(data);
-  bytes  := ArrayList(u8).with_capacity(usize(16));
+  bytes := ArrayList(u8).with_capacity(usize(16));
   i := usize(0);
-  while (i < usize(16)), (i = (i + usize(1))), {
+  while(i < usize(16), i = (i + usize(1)), {
     bytes.push(digest(i));
-  };
+  });
   hex_encode(bytes)
 });
-
-export md5_hex;
+export(md5_hex);

package/std/crypto/random.yo

@@ -9,56 +9,52 @@
 //!
 //! id := uuid_v4();  // "550e8400-e29b-41d4-a716-446655440000"
 //! ```
-
-{ ArrayList } :: import "../collections/array_list";
-{ platform, Platform } :: import "../process";
-open import "../string";
-{ snprintf } :: import "../libc/stdio";
-{ hex_encode } :: import "../encoding/hex";
-{ Error, AnyError, Exception } :: import "../error";
-{ ToString } :: import "../fmt";
-
+{ ArrayList } :: import("../collections/array_list");
+{ platform, Platform } :: import("../process");
+open(import("../string"));
+{ snprintf } :: import("../libc/stdio");
+{ hex_encode } :: import("../encoding/hex");
+{ Error, AnyError, Exception } :: import("../error");
+{ ToString } :: import("../fmt");
 // ============================================================================
 // Error type
 // ============================================================================
-
 /// Errors that can occur during cryptographic random operations.
 CryptoError :: enum(
   /// Platform does not support secure random generation.
   Unavailable,
   /// Other platform-specific error.
-  Other(msg: String)
+  Other(msg : String)
 );
-
-impl(CryptoError, ToString(
-  to_string : (self ->
-    match(self,
-      .Unavailable => `crypto: platform random unavailable`,
-      .Other(msg) => `crypto error: ${msg}`
+impl(
+  CryptoError,
+  ToString(
+    to_string : (
+      self ->
+        match(
+          self,
+          .Unavailable => `crypto: platform random unavailable`,
+          .Other(msg) => `crypto error: ${msg}`
+        )
     )
   )
-));
-
+);
 impl(CryptoError, Error());
-
-export CryptoError;
-
+export(CryptoError);
 // ============================================================================
 // Platform externs
 // ============================================================================
-
-extern "Yo",
-  __yo_getrandom     : (fn(buf: *(u8), buflen: usize, flags: u32) -> isize),
-  __yo_arc4random_buf: (fn(buf: *(u8), nbytes: usize) -> unit),
-  __yo_bcrypt_gen_random: (fn(buf: *(u8), size: u32) -> i32),
-  __yo_getentropy: (fn(buf: *(u8), buflen: usize) -> i32)
-;
-
+extern(
+  "Yo",
+  __yo_getrandom : (fn(buf : *(u8), buflen : usize, flags : u32) -> isize),
+  __yo_arc4random_buf : (fn(buf : *(u8), nbytes : usize) -> unit),
+  __yo_bcrypt_gen_random : (fn(buf : *(u8), size : u32) -> i32),
+  __yo_getentropy : (fn(buf : *(u8), buflen : usize) -> i32)
+);
 // ============================================================================
 // Fill a buffer with cryptographically secure random bytes.
 // ============================================================================
-
-random_bytes :: (fn(buf: *(u8), size: usize, using(exn : Exception)) -> unit)(
+random_bytes :: (fn(buf : *(u8), size : usize, using(exn : Exception)) -> unit)(
   cond(
     (platform == Platform.Macos) => {
       __yo_arc4random_buf(buf, size);
@@ -67,82 +63,79 @@ random_bytes :: (fn(buf: *(u8), size: usize, using(exn : Exception)) -> unit)(
       r := __yo_bcrypt_gen_random(buf, u32(size));
       cond(
         (r == i32(0)) => (),
-        true => { exn.throw(dyn CryptoError.Unavailable); }
+        true => {
+          exn.throw(dyn(CryptoError.Unavailable));
+        }
       );
     },
     ((platform == Platform.Emscripten) || (platform == Platform.Wasi)) => {
       // WASM/Emscripten/WASI: getentropy() via WASI random_get (max 256 bytes per call)
       remaining := size;
       offset := usize(0);
-      while (remaining > usize(0)), {
+      while(remaining > usize(0), {
         chunk := cond(
           (remaining > usize(256)) => usize(256),
           true => remaining
         );
-        ret := __yo_getentropy((buf &+ offset), chunk);
+        ret := __yo_getentropy(buf &+ offset, chunk);
         cond(
-          (ret < i32(0)) => { exn.throw(dyn CryptoError.Unavailable); },
+          (ret < i32(0)) => {
+            exn.throw(dyn(CryptoError.Unavailable));
+          },
           true => ()
         );
         offset = (offset + chunk);
         remaining = (remaining - chunk);
-      };
+      });
     },
     true => {
       // Linux: getrandom syscall
       ret := __yo_getrandom(buf, size, u32(0));
       cond(
-        (ret < isize(0)) => { exn.throw(dyn CryptoError.Unavailable); },
+        (ret < isize(0)) => {
+          exn.throw(dyn(CryptoError.Unavailable));
+        },
         true => ()
       );
     }
   )
 );
-
-export random_bytes;
-
+export(random_bytes);
 // ============================================================================
 // Typed helpers
 // ============================================================================
-
 random_u32 :: (fn(using(exn : Exception)) -> u32)({
   buf := Array(u8, usize(4)).fill(u8(0));
   buf_ptr := &(buf(usize(0)));
   random_bytes(buf_ptr, usize(4));
-  (u32(buf(usize(0))) |
-   (u32(buf(usize(1))) << u32(8)) |
-   (u32(buf(usize(2))) << u32(16)) |
-   (u32(buf(usize(3))) << u32(24)))
-});
-
+  u32(buf(usize(0))) |
+    (u32(buf(usize(1))) << u32(8)) |
+      (u32(buf(usize(2))) << u32(16)) |
+        (u32(buf(usize(3))) << u32(24))
+      });
 random_u64 :: (fn(using(exn : Exception)) -> u64)({
   lo := u64(random_u32());
   hi := u64(random_u32());
-  (lo | (hi << u64(32)))
+  lo | (hi << u64(32))
 });
-
 random_f64 :: (fn(using(exn : Exception)) -> f64)(
-  (f64(random_u64()) / f64(18446744073709551615.0))
+  f64(random_u64()) / f64(18446744073709551615.0)
 );
-
 // Return a random integer in the half-open range [min, max).
-random_range :: (fn(min: i64, max: i64, using(exn : Exception)) -> i64)({
+random_range :: (fn(min : i64, max : i64, using(exn : Exception)) -> i64)({
   span := (max - min);
   cond(
     (span <= i64(0)) => min,
     true => {
       r := random_u64();
-      (min + i64((r % u64(span))))
+      min + i64(r % u64(span))
     }
   )
 });
-
-export random_u32, random_u64, random_f64, random_range;
-
+export(random_u32, random_u64, random_f64, random_range);
 // ============================================================================
 // UUID v4
 // ============================================================================
-
 // Generate a random UUID v4 string: "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
 uuid_v4 :: (fn(using(exn : Exception)) -> String)({
   bytes := ArrayList(u8).with_capacity(usize(16));
@@ -154,9 +147,9 @@ uuid_v4 :: (fn(using(exn : Exception)) -> String)({
   // Set variant bits
   buf(usize(8)) = ((buf(usize(8)) & u8(0x3F)) | u8(0x80));
   i := usize(0);
-  while (i < usize(16)), (i = (i + usize(1))), {
+  while(i < usize(16), i = (i + usize(1)), {
     bytes.push(buf(i));
-  };
+  });
   hex := hex_encode(bytes);
   hex_bytes := hex.as_bytes();
   // Insert dashes: 8-4-4-4-12
@@ -164,7 +157,7 @@ uuid_v4 :: (fn(using(exn : Exception)) -> String)({
   positions := Array(usize, usize(4))(usize(8), usize(12), usize(16), usize(20));
   j := usize(0);
   dash_idx := usize(0);
-  while (j < hex_bytes.len()), (j = (j + usize(1))), {
+  while(j < hex_bytes.len(), j = (j + usize(1)), {
     cond(
       ((dash_idx < usize(4)) && (j == positions(dash_idx))) => {
         out.push(u8(45)); // '-'
@@ -173,8 +166,7 @@ uuid_v4 :: (fn(using(exn : Exception)) -> String)({
       true => ()
     );
     out.push(hex_bytes.get(j).unwrap());
-  };
+  });
   String.from_bytes(out)
 });
-
-export uuid_v4;
+export(uuid_v4);