Phase 5-7: generic inference, extend Type<T>, String stdlib, Map<K,V>, self-hosting audit, docs update

2026-05-31 13:06:29 +03:00
parent 25f846bb00
commit 5c1a00cbd6
17 changed files with 1329 additions and 134 deletions
@@ -6,5 +6,22 @@ extern func PrintInt(n: int);
 extern func PrintFloat(f: float64);
 extern func PrintBool(b: bool);
 extern func ReadLine() -> String;
+extern func bux_read_file(path: String) -> String;
+extern func bux_write_file(path: String, content: String) -> int;
+extern func bux_file_exists(path: String) -> int;
+
+func ReadFile(path: String) -> String {
+    return bux_read_file(path);
+}
+
+func WriteFile(path: String, content: String) -> bool {
+    let r: int = bux_write_file(path, content);
+    return r != 0;
+}
+
+func FileExists(path: String) -> bool {
+    let r: int = bux_file_exists(path);
+    return r != 0;
+}

 }
@@ -1,31 +1,120 @@
 module Std::Map {

+extern func bux_hash_bytes(ptr: *void, size: uint) -> uint;
 extern func bux_hash_string(s: String) -> uint;

-struct MapEntry {
-    key: String,
-    value: int,
+// ---------------------------------------------------------------------------
+// Generic Map<K, V> — works with value-type keys (int, float, etc.)
+// For String keys, use StringMap below.
+// ---------------------------------------------------------------------------
+
+struct MapEntry<K, V> {
+    key: K,
+    value: V,
    occupied: bool,
 }

-struct Map {
-    entries: *MapEntry,
+struct Map<K, V> {
+    entries: *MapEntry<K, V>,
    cap: uint,
    len: uint,
 }

-func Map_New(cap: uint) -> Map {
-    let total: uint = cap * sizeof(MapEntry);
-    let data: *MapEntry = bux_alloc(total) as *MapEntry;
+func Map_New<K, V>(cap: uint) -> Map<K, V> {
+    let total: uint = cap * sizeof(MapEntry<K, V>);
+    let data: *MapEntry<K, V> = bux_alloc(total) as *MapEntry<K, V>;
    var i: uint = 0;
    while i < cap {
        data[i].occupied = false;
        i = i + 1;
    }
-    return Map { entries: data, cap: cap, len: 0 };
+    return Map<K, V> { entries: data, cap: cap, len: 0 };
 }

-func Map_Set(m: *Map, key: String, value: int) {
+func Map_Set<K, V>(m: *Map<K, V>, key: K, value: V) {
+    var keyPtr: *K = &key;
+    let hash: uint = bux_hash_bytes(keyPtr as *void, sizeof(K));
+    var idx: uint = hash % m.cap;
+    while m.entries[idx].occupied {
+        if m.entries[idx].key == key {
+            m.entries[idx].value = value;
+            return;
+        }
+        idx = (idx + 1) % m.cap;
+    }
+    m.entries[idx].key = key;
+    m.entries[idx].value = value;
+    m.entries[idx].occupied = true;
+    m.len = m.len + 1;
+}
+
+func Map_Get<K, V>(m: *Map<K, V>, key: K) -> V {
+    var keyPtr: *K = &key;
+    let hash: uint = bux_hash_bytes(keyPtr as *void, sizeof(K));
+    var idx: uint = hash % m.cap;
+    while m.entries[idx].occupied {
+        if m.entries[idx].key == key {
+            return m.entries[idx].value;
+        }
+        idx = (idx + 1) % m.cap;
+    }
+    // Return zero value for missing key
+    var zero: V = 0 as V;
+    return zero;
+}
+
+func Map_Has<K, V>(m: *Map<K, V>, key: K) -> bool {
+    var keyPtr: *K = &key;
+    let hash: uint = bux_hash_bytes(keyPtr as *void, sizeof(K));
+    var idx: uint = hash % m.cap;
+    while m.entries[idx].occupied {
+        if m.entries[idx].key == key {
+            return true;
+        }
+        idx = (idx + 1) % m.cap;
+    }
+    return false;
+}
+
+func Map_Len<K, V>(m: *Map<K, V>) -> uint {
+    return m.len;
+}
+
+func Map_Free<K, V>(m: *Map<K, V>) {
+    bux_free(m.entries as *void);
+    m.entries = null as *MapEntry<K, V>;
+    m.cap = 0;
+    m.len = 0;
+}
+
+// ---------------------------------------------------------------------------
+// StringMap<V> — specialized Map for String keys, using strcmp
+// ---------------------------------------------------------------------------
+
+struct StringMapEntry<V> {
+    key: String,
+    value: V,
+    occupied: bool,
+}
+
+struct StringMap<V> {
+    entries: *StringMapEntry<V>,
+    cap: uint,
+    len: uint,
+}
+
+func StringMap_New<V>(cap: uint) -> StringMap<V> {
+    let total: uint = cap * sizeof(StringMapEntry<V>);
+    let data: *StringMapEntry<V> = bux_alloc(total) as *StringMapEntry<V>;
+    var i: uint = 0;
+    while i < cap {
+        data[i].occupied = false;
+        i = i + 1;
+    }
+    return StringMap<V> { entries: data, cap: cap, len: 0 };
+}
+
+func StringMap_Set<V>(m: *StringMap<V>, key: String, value: V) {
    let hash: uint = bux_hash_string(key);
    var idx: uint = hash % m.cap;
    while m.entries[idx].occupied {
@@ -41,7 +130,7 @@ func Map_Set(m: *Map, key: String, value: int) {
    m.len = m.len + 1;
 }

-func Map_Get(m: *Map, key: String) -> int {
+func StringMap_Get<V>(m: *StringMap<V>, key: String) -> V {
    let hash: uint = bux_hash_string(key);
    var idx: uint = hash % m.cap;
    while m.entries[idx].occupied {
@@ -50,10 +139,11 @@ func Map_Get(m: *Map, key: String) -> int {
        }
        idx = (idx + 1) % m.cap;
    }
-    return 0;
+    var zero: V = 0 as V;
+    return zero;
 }

-func Map_Has(m: *Map, key: String) -> bool {
+func StringMap_Has<V>(m: *StringMap<V>, key: String) -> bool {
    let hash: uint = bux_hash_string(key);
    var idx: uint = hash % m.cap;
    while m.entries[idx].occupied {
@@ -65,15 +155,15 @@ func Map_Has(m: *Map, key: String) -> bool {
    return false;
 }

-func Map_Len(m: *Map) -> uint {
+func StringMap_Len<V>(m: *StringMap<V>) -> uint {
    return m.len;
 }

-func Map_Free(m: *Map) {
+func StringMap_Free<V>(m: *StringMap<V>) {
    bux_free(m.entries as *void);
-    m.entries = null as *MapEntry;
+    m.entries = null as *StringMapEntry<V>;
    m.cap = 0;
    m.len = 0;
 }

-}
+}
@@ -0,0 +1,19 @@
+module Std::Path {
+
+extern func bux_path_join(a: String, b: String) -> String;
+extern func bux_path_parent(path: String) -> String;
+extern func bux_path_ext(path: String) -> String;
+
+func Path_Join(a: String, b: String) -> String {
+    return bux_path_join(a, b);
+}
+
+func Path_Parent(path: String) -> String {
+    return bux_path_parent(path);
+}
+
+func Path_Ext(path: String) -> String {
+    return bux_path_ext(path);
+}
+
+}
@@ -6,6 +6,25 @@ extern func bux_strncmp(a: String, b: String, n: uint) -> int;
 extern func bux_strcpy(dest: *char8, src: String) -> *char8;
 extern func bux_strcat(dest: *char8, src: String) -> *char8;
 extern func bux_strncpy(dest: *char8, src: String, n: uint) -> *char8;
+extern func bux_strstr(haystack: String, needle: String) -> String;
+extern func bux_str_contains(haystack: String, needle: String) -> int;
+extern func bux_str_slice(s: String, start: uint, len: uint) -> String;
+extern func bux_str_trim_left(s: String) -> String;
+extern func bux_str_trim_right(s: String) -> String;
+extern func bux_str_trim(s: String) -> String;
+extern func bux_int_to_str(n: int64) -> String;
+extern func bux_str_to_int(s: String) -> int64;
+extern func bux_sb_new(initial_cap: uint) -> *void;
+extern func bux_sb_append(sb: *void, s: String);
+extern func bux_sb_append_int(sb: *void, n: int64);
+extern func bux_sb_append_float(sb: *void, f: float64);
+extern func bux_sb_append_char(sb: *void, c: char8);
+extern func bux_sb_build(sb: *void) -> String;
+extern func bux_sb_free(sb: *void);
+extern func bux_str_split_count(s: String, delim: String) -> uint;
+extern func bux_str_split_part(s: String, delim: String, index: uint) -> String;
+extern func bux_str_join2(a: String, b: String, sep: String) -> String;
+

 func String_Len(s: String) -> uint {
    return bux_strlen(s);
@@ -42,4 +61,98 @@ func String_StartsWith(s: String, prefix: String) -> bool {
    return r == 0;
 }

+func String_EndsWith(s: String, suffix: String) -> bool {
+    let s_len: uint = bux_strlen(s);
+    let suf_len: uint = bux_strlen(suffix);
+    if suf_len > s_len {
+        return false;
+    }
+    let start: uint = s_len - suf_len;
+    let tail: String = bux_str_slice(s, start, suf_len);
+    let eq: bool = bux_strcmp(tail, suffix) == 0;
+    return eq;
 }
+
+func String_Contains(s: String, substr: String) -> bool {
+    let r: int = bux_str_contains(s, substr);
+    return r != 0;
+}
+
+func String_Slice(s: String, start: uint, len: uint) -> String {
+    return bux_str_slice(s, start, len);
+}
+
+func String_Trim(s: String) -> String {
+    return bux_str_trim(s);
+}
+
+func String_TrimLeft(s: String) -> String {
+    return bux_str_trim_left(s);
+}
+
+func String_TrimRight(s: String) -> String {
+    return bux_str_trim_right(s);
+}
+
+func String_FromInt(n: int64) -> String {
+    return bux_int_to_str(n);
+}
+
+func String_ToInt(s: String) -> int64 {
+    return bux_str_to_int(s);
+}
+
+// String Builder — efficient string construction
+struct StringBuilder {
+    handle: *void,
+}
+
+func StringBuilder_New() -> StringBuilder {
+    return StringBuilder { handle: bux_sb_new(64) };
+}
+
+func StringBuilder_NewCap(cap: uint) -> StringBuilder {
+    return StringBuilder { handle: bux_sb_new(cap) };
+}
+
+func StringBuilder_Append(sb: *StringBuilder, s: String) {
+    bux_sb_append(sb.handle, s);
+}
+
+func StringBuilder_AppendInt(sb: *StringBuilder, n: int64) {
+    bux_sb_append_int(sb.handle, n);
+}
+
+func StringBuilder_AppendFloat(sb: *StringBuilder, f: float64) {
+    bux_sb_append_float(sb.handle, f);
+}
+
+func StringBuilder_AppendChar(sb: *StringBuilder, c: char8) {
+    bux_sb_append_char(sb.handle, c);
+}
+
+func StringBuilder_Build(sb: *StringBuilder) -> String {
+    return bux_sb_build(sb.handle);
+}
+
+func StringBuilder_Free(sb: *StringBuilder) {
+    bux_sb_free(sb.handle);
+}
+
+// ---------------------------------------------------------------------------
+// String split/join
+// ---------------------------------------------------------------------------
+
+func String_SplitCount(s: String, delim: String) -> uint {
+    return bux_str_split_count(s, delim);
+}
+
+func String_SplitPart(s: String, delim: String, index: uint) -> String {
+    return bux_str_split_part(s, delim, index);
+}
+
+func String_Join2(a: String, b: String, sep: String) -> String {
+    return bux_str_join2(a, b, sep);
+}
+
+}