@tishlang/tish-format 3.2.2 → 3.3.0

package/crates/tish_runtime_gba/src/gba.rs

@@ -101,21 +101,41 @@ type BgAsset = (
     &'static agb::display::tile_data::TileData,
 );
 
-static ASSET_BGS: SingleCore<RefCell<Vec<BgAsset>>> = SingleCore::new(RefCell::new(Vec::new()));
+/// ⚠️ A FIXED TABLE, not a `Vec`, because every entry is `&'static` cartridge data and the registry
+/// never needed to own one.
+///
+/// As a `Vec` it did: registering N backgrounds ran N pushes with log2(N) reallocs, all during
+/// module init before the program body, and the freed buffers left the heap too fragmented for the
+/// one big contiguous block a GBA UI canvas wants. A game with a handful of backgrounds booted; a
+/// game with 162 died in the allocator with plenty of total heap free.
+///
+/// This costs `MAX_BGS * size_of::<Option<BgAsset>>()` of STATIC memory and allocates nothing.
+/// ⚠️ Not a `Vec` with `reserve` — that charges every small game for the largest one.
+const MAX_BGS: usize = 256;
+static ASSET_BGS: SingleCore<RefCell<[Option<BgAsset>; MAX_BGS]>> =
+    SingleCore::new(RefCell::new([None; MAX_BGS]));
+static ASSET_BGS_N: SingleCore<RefCell<usize>> = SingleCore::new(RefCell::new(0));
 
 /// Register a background (palettes + tile data), returning its i32 handle.
 pub fn __asset_register_bg(bg: BgAsset) -> i32 {
-    ASSET_BGS.with(|c| {
-        let mut v = c.borrow_mut();
-        let idx = v.len() as i32;
-        v.push(bg);
+    ASSET_BGS_N.with(|n| {
+        let mut n = n.borrow_mut();
+        if *n >= MAX_BGS {
+            return -1;
+        }
+        let idx = *n as i32;
+        ASSET_BGS.with(|c| c.borrow_mut()[*n] = Some(bg));
+        *n += 1;
         idx
     })
 }
 
 /// Look up a registered background by handle. `None` if out of range.
 pub fn asset_bg(handle: i32) -> Option<BgAsset> {
-    ASSET_BGS.with(|c| c.borrow().get(handle as usize).copied())
+    if handle < 0 || handle as usize >= MAX_BGS {
+        return None;
+    }
+    ASSET_BGS.with(|c| c.borrow()[handle as usize])
 }
 
 /// Registered fonts (`font<N>:` imports) — a compile-time-baked `Font`. All `font<N>:` schemes share

package/crates/tish_runtime_gba/src/lib.rs

@@ -283,6 +283,35 @@ pub fn str_index(s: &str, idx: &Value) -> Value {
     }
 }
 
+/// `&str` charCodeAt — the code unit at `idx`, NaN when out of range. Mirrors
+/// `tish_runtime::str_char_code_at`, and missing here for the same reason `str_index` was: codegen
+/// emits it whenever the receiver is statically a `&str`, so `"abc".charCodeAt(i)` was a hard E0425
+/// on the GBA target only while compiling everywhere else. Found by a ROM that hashes its own trace.
+#[inline]
+pub fn str_char_code_at(s: &str, idx: &Value) -> Value {
+    let i = match idx {
+        Value::Number(n) if *n >= 0.0 && n.fract() == 0.0 => *n as usize,
+        _ => return Value::Number(f64::NAN),
+    };
+    match s.chars().nth(i) {
+        Some(c) => Value::Number(c as u32 as f64),
+        None => Value::Number(f64::NAN),
+    }
+}
+
+/// `&str` charAt — the 1-character string at `idx`, `""` out of range. Same reason as above.
+#[inline]
+pub fn str_char_at(s: &str, idx: &Value) -> Value {
+    let i = match idx {
+        Value::Number(n) if *n >= 0.0 && n.fract() == 0.0 => *n as usize,
+        _ => return Value::String("".into()),
+    };
+    match s.chars().nth(i) {
+        Some(c) => Value::String(c.to_string().into()),
+        None => Value::String("".into()),
+    }
+}
+
 pub fn delete_property(obj: &Value, key: &Value) -> Value {
     match obj {
         Value::Object(m) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish-format",
-  "version": "3.2.2",
+  "version": "3.3.0",
   "description": "Tish code formatter",
   "license": "PIF",
   "repository": {