feat: expand standard library with math and string modules (#270)

This commit populates the Wave standard library with foundational
modules for mathematics and string manipulation. It also updates
the library manifest and provides a basic README.

Changes:
- **Library Infrastructure**:
  - Added `std/README.md` to define the library's scope.
  - Updated `std/manifest.json` to include the `math` and `string` modules.
- **`std/math` Module**:
  - `bits.wave`: Implemented bitwise utilities including `is_pow2`,
    `popcount`, `ctz32`, and integer logarithm functions (`ilog2`).
  - `float.wave`: Added `abs`, `min`, `max`, and `clamp` for `f32`.
  - `int.wave`: Added integer utilities including `abs`, `sign`, parity
    checks, ceiling/floor division, and a pointer-based `swap_i32`.
  - `num.wave`: Implemented `gcd`, `lcm`, and exponentiation (`pow_i32`).
- **`std/string` Module**:
  - `ascii.wave`: Added ASCII character classification (digit, alpha,
    space, etc.) and case conversion.
  - `cmp.wave`: Implemented string equality, lexical comparison, and
    prefix/suffix checks (`starts_with`, `ends_with`).
  - `find.wave`: Added character and substring searching logic,
    including `find`, `contains`, and `count`.
  - `len.wave`: Added basic length and empty-string checks.
  - `trim.wave`: Implemented index-based whitespace trimming for strings.
- **Cleanup**:
  - Removed obsolete `import("std::iosys")` calls from test files.

These additions provide the essential building blocks for writing
complex Wave applications using standardized utility functions.

Signed-off-by: LunaStev <luna@lunastev.org>

Author: LunaStev

std/README.md

@@ -0,0 +1,3 @@
+# Wave Standard Library
+
+This is Wave's standard library. This standard library operates independently of Wave's compiler and is not part of the compiler itself.

std/io/format.wave

@@ -1,5 +1,5 @@
 {
   "name": "std",
   "format": 1,
-  "modules": ["io", "fs", "net", "math", "sys", "json"]
+  "modules": ["string", "math"]
 }

std/manifest.json

@@ -0,0 +1,84 @@
+fun is_pow2(x: i32) -> bool {
+    if (x <= 0) {
+        return false;
+    }
+
+    if ((x & (x - 1)) == 0) {
+        return true;
+    }
+
+    return false;
+}
+
+fun align_down(x: i32, align: i32) -> i32 {
+    if (align <= 0) {
+        return x;
+    }
+
+    return x & ~(align - 1);
+}
+
+fun align_up(x: i32, align: i32) -> i32 {
+    if (align <= 0) {
+        return x;
+    }
+
+    return (x + (align - 1)) & ~(align - 1);
+}
+
+fun low_bit(x: i32) -> i32 {
+    return x & (-x);
+}
+
+fun popcount(x0: i32) -> i32 {
+    let mut x: i32 = x0;
+    let mut c: i32 = 0;
+
+    while (x != 0) {
+        x = x & (x - 1);
+        c += 1;
+    }
+
+    return c;
+}
+
+fun ctz32(x: i32) -> i32 {
+    if (x == 0) {
+        return 32;
+    }
+
+    let lb: i32 = low_bit(x);
+    return popcount(lb - 1);
+}
+
+fun bit_length(x0: i32) -> i32 {
+    if (x0 <= 0) {
+        return 0;
+    }
+
+    let mut x: i32 = x0;
+    let mut n: i32 = 0;
+
+    while (x > 0) {
+        x = x >> 1;
+        n += 1;
+    }
+
+    return n;
+}
+
+fun ilog2_floor(x: i32) -> i32 {
+    if (x <= 0) {
+        return -1;
+    }
+
+    return bit_length(x) - 1;
+}
+
+fun ilog2_ceil(x: i32) -> i32 {
+    if (x <= 1) {
+        return 0;
+    }
+
+    return ilog2_floor(x - 1) + 1;
+}

std/math/bits.wave

@@ -0,0 +1,35 @@
+fun abs_f32(x: f32) -> f32 {
+    if (x < 0.0) {
+        return -x;
+    }
+
+    return x;
+}
+
+fun min_f32(a: f32, b: f32) -> f32 {
+    if (a < b) {
+        return a;
+    }
+
+    return b;
+}
+
+fun max_f32(a: f32, b: f32) -> f32 {
+    if (a > b) {
+        return a;
+    }
+
+    return b;
+}
+
+fun clamp_f32(x: f32, lo: f32, hi: f32) -> f32 {
+    if (x < lo) {
+        return lo;
+    }
+
+    if (x > hi) {
+        return hi;
+    }
+
+    return x;
+}

std/math/float.wave

@@ -0,0 +1,94 @@
+fun abs(x: i32) -> i32 {
+    if (x < 0) {
+        return -x;
+    }
+
+    return x;
+}
+
+fun min(a: i32, b: i32) -> i32 {
+    if (a < b) {
+        return a;
+    }
+
+    return b;
+}
+
+fun max(a: i32, b: i32) -> i32 {
+    if (a > b) {
+        return a;
+    }
+
+    return b;
+}
+
+fun clamp(x: i32, lo: i32, hi: i32) -> i32 {
+    if (x < lo) {
+        return lo;
+    }
+
+    if (x > hi) {
+        return hi;
+    }
+
+    return x;
+}
+
+fun sign(x: i32) -> i32 {
+    if (x < 0) {
+        return -1;
+    }
+
+    if (x > 0) {
+        return 1;
+    }
+
+    return 0;
+}
+
+fun is_even(x: i32) -> bool {
+    if ((x % 2) == 0) {
+        return true;
+    }
+
+    return false;
+}
+
+fun is_odd(x: i32) -> bool {
+    if ((x % 2) != 0) {
+        return true;
+    }
+
+    return false;
+}
+
+fun div_ceil_pos(a: i32, b: i32) -> i32 {
+    if (b == 0) {
+        return 0;
+    }
+
+    if (a <= 0) {
+        return 0;
+    }
+
+    return (a + (b - 1)) / b;
+}
+
+fun div_floor_pos(a: i32, b: i32) -> i32 {
+    if (b == 0) {
+        return 0;
+    }
+
+    if (a <= 0) {
+        return 0;
+    }
+
+    return a / b;
+}
+
+fun swap_i32(a: ptr<i32>, b: ptr<i32>) {
+    let t: i32 = deref a;
+
+    deref a = deref b;
+    deref b = t;
+}

std/math/int.wave

@@ -0,0 +1,53 @@
+fun gcd(a0: i32, b0: i32) -> i32 {
+    let mut a: i32 = a0;
+    let mut b: i32 = b0;
+
+    if (a < 0) {
+        a = -a;
+    }
+
+    if (b < 0) {
+        b = -b;
+    }
+
+    while (b != 0) {
+        let t: i32 = a % b;
+        a = b;
+        b = t;
+    }
+
+    return a;
+}
+
+fun lcm(a: i32, b: i32) -> i32 {
+    if (a == 0 || b == 0) {
+        return 0;
+    }
+
+    let g: i32 = gcd(a, b);
+    let x: i32 = a / g;
+    let mut r: i32 = x * b;
+
+    if (r < 0) {
+        r = -r;
+    }
+
+    return r;
+}
+
+fun pow_i32(base0: i32, exp0: i32) -> i32 {
+    let mut base: i32 = base0;
+    let mut exp: i32 = exp0;
+    let mut result: i32 = 1;
+
+    while (exp > 0) {
+        if ((exp & 1) == 1) {
+            result = result * base;
+        }
+
+        base = base * base;
+        exp = exp >> 1;
+    }
+
+    return result;
+}

std/math/num.wave

@@ -0,0 +1,83 @@
+fun is_digit(c: u8) -> bool {
+    if (c >= 48 && c <= 57) {
+        return true;
+    }
+
+    return false;
+}
+
+fun is_lower(c: u8) -> bool {
+    if (c >= 97 && c <= 122) {
+        return true;
+    }
+
+    return false;
+}
+
+fun is_upper(c: u8) -> bool {
+    if (c >= 65 && c <= 90) {
+        return true;
+    }
+
+    return false;
+}
+
+fun is_alpha(c: u8) -> bool {
+    if (is_lower(c)) {
+        return true;
+    }
+
+    if (is_upper(c)) {
+        return true;
+    }
+
+    return false;
+}
+
+fun is_alnum(c: u8) -> bool {
+    if (is_alpha(c)) {
+        return true;
+    }
+
+    if (is_digit(c)) {
+        return true;
+    }
+
+    return false;
+}
+
+fun is_space(c: u8) -> bool {
+    if (c == 32) {
+        return true;
+    }
+
+    if (c == 9) {
+        return true;
+    }
+
+    if (c == 10) {
+        return true;
+    }
+
+    if (c == 13) {
+        return true;
+    }
+
+    return false;
+}
+
+fun to_lower(c: u8) -> u8 {
+    if (is_upper(c)) {
+        return c + 32;
+    }
+
+    return c;
+}
+
+fun to_upper(c: u8) -> u8 {
+    if (is_lower(c)) {
+        return c - 32;
+    }
+
+    return c;
+}