@shd101wyy/yo 0.1.0 → 0.1.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shd101wyy/yo",
   "displayName": "Yo",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "main": "./out/cjs/index.cjs",
   "module": "./out/esm/index.mjs",
   "types": "./out/types/src/index.d.ts",

package/std/build.yo

@@ -51,6 +51,20 @@ StepKind :: enum(
 );
 export StepKind;
 
+// ── Compilation targets ──────────────────────────────────────────────
+
+CompilationTarget :: {
+  X86_64_Linux_Gnu: "x86_64-linux-gnu",
+  X86_64_Linux_Musl: "x86_64-linux-musl",
+  Aarch64_Linux_Gnu: "aarch64-linux-gnu",
+  Aarch64_Macos: "aarch64-macos",
+  X86_64_Macos: "x86_64-macos",
+  X86_64_Windows_Msvc: "x86_64-windows-msvc",
+  Wasm32_Emscripten: "wasm32-emscripten",
+  Wasm32_Wasi: "wasm32-wasi"
+};
+export CompilationTarget;
+
 // ── Target utilities ─────────────────────────────────────────────────
 
 target_host :: __yo_build_target_host();

package/std/crypto/random.yo

@@ -4,6 +4,7 @@
 //   Linux/others: getrandom()
 //   macOS:        arc4random_buf()
 //   Windows:      BCryptGenRandom()
+//   WASI/WASM:    getentropy()
 //
 // Example:
 //   { random_u64, uuid_v4 } :: import "std/crypto/random";
@@ -47,7 +48,8 @@ export CryptoError;
 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_bcrypt_gen_random: (fn(buf: *(u8), size: u32) -> i32),
+  __yo_getentropy: (fn(buf: *(u8), buflen: usize) -> i32)
 ;
 
 // ============================================================================
@@ -66,6 +68,24 @@ random_bytes :: (fn(buf: *(u8), size: usize, using(exn : Exception)) -> unit)(
         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)), {
+        chunk := cond(
+          (remaining > usize(256)) => usize(256),
+          true => remaining
+        );
+        ret := __yo_getentropy((buf &+ offset), chunk);
+        cond(
+          (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));

package/std/fs/dir.yo

@@ -25,6 +25,7 @@ open import "../string";
 { Path } :: import "../path";
 { IOError } :: import "../sys/errors";
 { Error, AnyError, Exception } :: import "../error";
+{ EEXIST, ENOENT } :: import "../libc/errno";
 IO_dir :: import "../sys/dir";
 IO_file :: import "../sys/file";
 { platform, Platform } :: import "../process";
@@ -96,9 +97,9 @@ create_dir_all :: (fn(path: Path, using(io : IO)) -> Impl(Future(unit, IO, Excep
         errno := (i32(0) - result);
         cond(
           // Already exists is OK
-          (errno == i32(17)) => (),
+          (errno == i32(EEXIST)) => (),
           // ENOENT - try to create parents
-          (errno == i32(2)) => {
+          (errno == i32(ENOENT)) => {
             // Walk the path and create each component
             bytes := path_s.as_bytes();
             i := usize(1);
@@ -129,7 +130,7 @@ create_dir_all :: (fn(path: Path, using(io : IO)) -> Impl(Future(unit, IO, Excep
                   r := io.await(IO_dir.mkdir(AT_FDCWD, prefix_cstr, i32(DEFAULT_DIR_MODE)));
                   // Ignore EEXIST errors
                   cond(
-                    ((r < i32(0)) && ((i32(0) - r) != i32(17))) => {
+                    ((r < i32(0)) && ((i32(0) - r) != i32(EEXIST))) => {
                       exn.throw(dyn IOError.from_errno((i32(0) - r)));
                     },
                     true => ()
@@ -146,7 +147,7 @@ create_dir_all :: (fn(path: Path, using(io : IO)) -> Impl(Future(unit, IO, Excep
               true => {
                 final_errno := (i32(0) - final_result);
                 cond(
-                  (final_errno == i32(17)) => (),
+                  (final_errno == i32(EEXIST)) => (),
                   true => exn.throw(dyn IOError.from_errno(final_errno))
                 )
               }

package/std/prelude.yo

@@ -2241,8 +2241,14 @@ export f64 : _f64;
 
 /// isize
 impl(isize,
-  MIN : isize(-9223372036854775808),
-  MAX : isize(9223372036854775807)
+  MIN : cond(
+    (__yo_pointer_size_bits() == 32) => isize(-2147483648),
+    true => isize(-9223372036854775808)
+  ),
+  MAX : cond(
+    (__yo_pointer_size_bits() == 32) => isize(2147483647),
+    true => isize(9223372036854775807)
+  )
 );
 impl(isize, Send());
 impl(isize, Acyclic());
@@ -2394,7 +2400,10 @@ export isize : _isize;
 /// usize
 impl(usize,
   MIN : usize(0),
-  MAX : usize(18446744073709551615)
+  MAX : cond(
+    (__yo_pointer_size_bits() == 32) => usize(4294967295),
+    true => usize(18446744073709551615)
+  )
 );
 impl(usize, Send());
 impl(usize, Acyclic());

package/std/process.yo

@@ -14,6 +14,7 @@ open import "./path";
  * - "macos"
  * - "windows"
  * - "freebsd"
+ * - "emscripten"
  * - "wasi"
  */
 platform :: __yo_process_platform();
@@ -24,6 +25,7 @@ Platform :: {
   Macos : "macos",
   Windows : "windows",
   FreeBSD : "freebsd",
+  Emscripten : "emscripten",
   Wasi : "wasi"
 };
 export Platform;

package/std/regex/index.yo

@@ -143,7 +143,7 @@ impl(Regex,
 impl(Regex,
   _build_match : (fn(self : Self, slots : ArrayList(usize), input : String) -> RegexMatch)({
     bytes := input.as_bytes();
-    unset := usize(0xFFFFFFFFFFFFFFFF);
+    unset := usize.MAX;
 
     match_start_byte := slots.get(usize(0)).unwrap();
     match_end_byte := slots.get(usize(1)).unwrap();

package/std/regex/vm.yo

@@ -24,8 +24,8 @@ impl(NfaThread,
     s := ArrayList(usize).with_capacity(n_slots);
     i := usize(0);
     while (i < n_slots), (i = (i + usize(1))), {
-      // 0xFFFFFFFFFFFFFFFF signals "unset"
-      s.push(usize(0xFFFFFFFFFFFFFFFF));
+      // usize.MAX signals "unset"
+      s.push(usize.MAX);
     };
     Self(pc: pc, slots: s)
   }),
@@ -321,7 +321,7 @@ impl(NfaVm,
   // Run a sub-VM starting at sub_start_pc from start_byte.
   // If required_end is not UNSET, only succeed when Match is found at exactly required_end.
   _run_sub_vm : (fn(self : Self, sub_start_pc : usize, start_byte : usize, required_end : usize) -> bool)({
-    unset := usize(0xFFFFFFFFFFFFFFFF);
+    unset := usize.MAX;
     sub_current := ArrayList(NfaThread).new();
     sub_next := ArrayList(NfaThread).new();
 
@@ -458,7 +458,7 @@ impl(NfaVm,
     best_match := VmMatch(matched: false, slots: ArrayList(usize).new());
     byte_pos := start_byte;
     input_len := self._bytes.len();
-    unset := usize(0xFFFFFFFFFFFFFFFF);
+    unset := usize.MAX;
 
     while (byte_pos <= input_len), {
       (cur_cp : u32) = u32(0);

package/std/string/string.yo

@@ -587,7 +587,7 @@ impl(String,
    * Returns the character index of the last match, or None if not found
    * from_index specifies the character index to start searching backwards from
    */
-  last_index_of : (fn(self: Self, substr: Self, (from_index : usize) ?= 0xFFFFFFFFFFFFFFFF) -> Option(usize))(
+  last_index_of : (fn(self: Self, substr: Self, (from_index : usize) ?= usize.MAX) -> Option(usize))(
     cond(
       substr.is_empty() => .Some(self.len()),
       true => {
@@ -786,7 +786,7 @@ impl(String,
    * Check if the string ends with the specified substring (like JavaScript endsWith)
    * end_position: The character length to consider (default is string length)
    */
-  ends_with : (fn(self: Self, suffix: Self, (end_position : usize) ?= 0xFFFFFFFFFFFFFFFF) -> bool)({
+  ends_with : (fn(self: Self, suffix: Self, (end_position : usize) ?= usize.MAX) -> bool)({
     suffix_bytes := suffix._bytes.len();
     self_bytes := self._bytes.len();
 
@@ -796,7 +796,7 @@ impl(String,
         // Determine the effective end position in characters
         string_char_len := self.len();
         effective_end := cond(
-          (end_position == usize(0xFFFFFFFFFFFFFFFF)) => string_char_len,
+          (end_position == usize.MAX) => string_char_len,
           (end_position > string_char_len) => string_char_len,
           true => end_position
         );