extend default to s64

examples/modules/std.sx

@@ -1,15 +1,15 @@
 Vector :: ($N: int, $T: Type) -> Type #builtin;
 write :: (str: string) -> void #builtin;
 sqrt :: (x: $T) -> T #builtin;
-size_of :: ($T: Type) -> s32 #builtin;
-alloc :: (size: s32) -> string #builtin;
+size_of :: ($T: Type) -> s64 #builtin;
+alloc :: (size: s64) -> string #builtin;
 type_of :: (val: $T) -> Type #builtin;
 type_name :: ($T: Type) -> string #builtin;
-field_count :: ($T: Type) -> s32 #builtin;
-field_name :: ($T: Type, idx: s32) -> string #builtin;
-field_value :: (s: $T, idx: s32) -> Any #builtin;
+field_count :: ($T: Type) -> s64 #builtin;
+field_name :: ($T: Type, idx: s64) -> string #builtin;
+field_value :: (s: $T, idx: s64) -> Any #builtin;
 
-int_to_string :: (n: s32) -> string {
+int_to_string :: (n: s64) -> string {
     if n == 0 { return "0"; }
     neg := n < 0;
     v := if neg then 0 - n else n;
@@ -35,8 +35,8 @@ bool_to_string :: (b: bool) -> string {
 float_to_string :: (f: f64) -> string {
     neg := f < 0.0;
     v := if neg then 0.0 - f else f;
-    int_part := cast(s32) v;
-    frac := cast(s32) ((v - cast(f64) int_part) * 1000000.0);
+    int_part := cast(s64) v;
+    frac := cast(s64) ((v - cast(f64) int_part) * 1000000.0);
     if frac < 0 { frac = 0 - frac; }
     istr := int_to_string(int_part);
     fstr := int_to_string(frac);
@@ -59,6 +59,68 @@ float_to_string :: (f: f64) -> string {
     buf;
 }
 
+int_to_hex_string :: (n: s64) -> string {
+    if n == 0 { return "0"; }
+
+    // Split into four 16-bit groups for correct unsigned treatment
+    g0 := n % 65536;
+    if g0 < 0 { g0 = g0 + 65536; }
+    r1 := (n - g0) / 65536;
+    g1 := r1 % 65536;
+    if g1 < 0 { g1 = g1 + 65536; }
+    r2 := (r1 - g1) / 65536;
+    g2 := r2 % 65536;
+    if g2 < 0 { g2 = g2 + 65536; }
+    r3 := (r2 - g2) / 65536;
+    g3 := r3 % 65536;
+    if g3 < 0 { g3 = g3 + 65536; }
+
+    buf := alloc(16);
+    // Group 3: digits 0-3 (bits 48-63)
+    i := 3;
+    v := g3;
+    while i >= 0 {
+        d := v % 16;
+        buf[i] = if d < 10 then d + 48 else d - 10 + 97;
+        v = v / 16;
+        i -= 1;
+    }
+    // Group 2: digits 4-7 (bits 32-47)
+    i = 7;
+    v = g2;
+    while i >= 4 {
+        d := v % 16;
+        buf[i] = if d < 10 then d + 48 else d - 10 + 97;
+        v = v / 16;
+        i -= 1;
+    }
+    // Group 1: digits 8-11 (bits 16-31)
+    i = 11;
+    v = g1;
+    while i >= 8 {
+        d := v % 16;
+        buf[i] = if d < 10 then d + 48 else d - 10 + 97;
+        v = v / 16;
+        i -= 1;
+    }
+    // Group 0: digits 12-15 (bits 0-15)
+    i = 15;
+    v = g0;
+    while i >= 12 {
+        d := v % 16;
+        buf[i] = if d < 10 then d + 48 else d - 10 + 97;
+        v = v / 16;
+        i -= 1;
+    }
+    // Skip leading zeros (keep at least 1 digit)
+    start := 0;
+    while start < 15 {
+        if buf[start] != 48 { break; }
+        start += 1;
+    }
+    substr(buf, start, 16 - start);
+}
+
 concat :: (a: string, b: string) -> string {
     al := a.len;
     bl := b.len;
@@ -70,7 +132,7 @@ concat :: (a: string, b: string) -> string {
     buf;
 }
 
-substr :: (s: string, start: s32, len: s32) -> string {
+substr :: (s: string, start: s64, len: s64) -> string {
     buf := alloc(len);
     i := 0;
     while i < len {
@@ -94,7 +156,7 @@ struct_to_string :: (s: $T) -> string {
 }
 
 enum_to_string :: (e: $T) -> string {
-    concat(".", field_name(T, cast(s32) e));
+    concat(".", field_name(T, cast(s64) e));
 }
 
 vector_to_string :: (v: $T) -> string {
@@ -130,8 +192,13 @@ slice_to_string :: (items: []$T) -> string {
     concat(result, "]");
 }
 
+pointer_to_string :: (p: $T) -> string {
+    addr : s64 = xx p;
+    concat(type_name(T), concat("@", int_to_hex_string(addr)));
+}
+
 union_to_string :: (u: $T) -> string {
-    tag := cast(s32) u;
+    tag := cast(s64) u;
     result := concat(".", field_name(T, tag));
     payload := field_value(u, tag);
     pstr := any_to_string(payload);
@@ -156,6 +223,8 @@ any_to_string :: (val: Any) -> string {
         case array: result = array_to_string(cast(type) val);
         case slice: result = slice_to_string(cast(type) val);
         case union: result = union_to_string(cast(type) val);
+        case pointer: result = pointer_to_string(cast(type) val);
+        case type: { s : string = xx val; result = s; }
     }
     result;
 }