feat: expand standard library with math and string modules

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/manifest.json

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

std/math/bits.wave

@@ -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/float.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/int.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/num.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/string/ascii.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;
+}