atmos/os_lib/

json.rs

// src/json.rs - Lightweight JSON parser and serializer for AtmOS
#![allow(dead_code)]

extern crate alloc;
use alloc::collections::BTreeMap;
use alloc::string::String;
use alloc::vec::Vec;
use core::iter::Peekable;
use core::str::Chars;

#[derive(Debug, Clone, PartialEq)]
pub enum JsonValue {
    Null,
    Bool(bool),
    Number(f64),
    String(String),
    Array(Vec<JsonValue>),
    Object(BTreeMap<String, JsonValue>),
}

pub fn parse(input: &str) -> Result<JsonValue, String> {
    let mut chars = input.chars().peekable();
    parse_value(&mut chars, 0)
}

pub use parse as parse_json;

fn skip_whitespace(chars: &mut Peekable<Chars>) {
    while let Some(&c) = chars.peek() {
        if c.is_whitespace() {
            chars.next();
        } else {
            break;
        }
    }
}

// `depth` はRustのネイティブ再帰（`parse_value`→`parse_array`/`parse_object`→
// `parse_value`…の相互再帰）による呼出しの深さを追跡する。この処理系はブート時点の
// 初期コアスタックがわずか64KB（`boot.S`の`(CoreID+1)*64KB`）しか無く、`structuredClone`
// の深いネスト保護テストで一度実際にRustコールスタックオーバーフローによる無応答を
// 起こしている（2026-07-18、walkthrough.md参照）。同じ危険性が`JSON.parse`（この関数の
// JS側入口）にも及ぶため、同じ閾値30で打ち切る。
fn parse_value(chars: &mut Peekable<Chars>, depth: usize) -> Result<JsonValue, String> {
    if depth > 30 {
        return Err(String::from("Maximum nesting depth exceeded"));
    }
    skip_whitespace(chars);
    match chars.peek() {
        Some(&'n') => parse_null(chars),
        Some(&'t') | Some(&'f') => parse_bool(chars),
        Some(&'"') => parse_string(chars).map(JsonValue::String),
        Some(&'[') => parse_array(chars, depth),
        Some(&'{') => parse_object(chars, depth),
        Some(&c) if c == '-' || c.is_ascii_digit() => parse_number(chars),
        Some(c) => Err(alloc::format!("Unexpected character: {}", c)),
        None => Err(String::from("Unexpected end of input")),
    }
}

fn parse_null(chars: &mut Peekable<Chars>) -> Result<JsonValue, String> {
    let expected = "null";
    for ec in expected.chars() {
        if chars.next() != Some(ec) {
            return Err(String::from("Expected null"));
        }
    }
    Ok(JsonValue::Null)
}

fn parse_bool(chars: &mut Peekable<Chars>) -> Result<JsonValue, String> {
    let is_true = chars.peek() == Some(&'t');
    let expected = if is_true { "true" } else { "false" };
    for ec in expected.chars() {
        if chars.next() != Some(ec) {
            return Err(String::from("Expected bool"));
        }
    }
    Ok(JsonValue::Bool(is_true))
}

fn parse_string(chars: &mut Peekable<Chars>) -> Result<String, String> {
    chars.next(); // consume '"'
    let mut s = String::new();
    while let Some(&c) = chars.peek() {
        if c == '"' {
            chars.next();
            return Ok(s);
        } else if c == '\\' {
            chars.next();
            if let Some(ec) = chars.next() {
                match ec {
                    '"' => s.push('"'),
                    '\\' => s.push('\\'),
                    '/' => s.push('/'),
                    'b' => s.push('\x08'),
                    'f' => s.push('\x0C'),
                    'n' => s.push('\n'),
                    'r' => s.push('\r'),
                    't' => s.push('\t'),
                    _ => s.push(ec), // simplisitc fallback
                }
            } else {
                return Err(String::from("Unexpected end of input in escape sequence"));
            }
        } else {
            s.push(c);
            chars.next();
        }
    }
    Err(String::from("Unterminated string"))
}

fn parse_number(chars: &mut Peekable<Chars>) -> Result<JsonValue, String> {
    let mut buf = [0u8; 64];
    let mut len = 0usize;
    while let Some(&c) = chars.peek() {
        if c == '-' || c == '+' || c == '.' || c == 'e' || c == 'E' || c.is_ascii_digit() {
            if len < buf.len() && c.is_ascii() {
                buf[len] = c as u8;
                len += 1;
            }
            chars.next();
        } else {
            break;
        }
    }
    if let Ok(s) = core::str::from_utf8(&buf[..len]) {
        match s.parse::<f64>() {
            Ok(n) => Ok(JsonValue::Number(n)),
            Err(_) => Err(alloc::format!("Invalid number: {}", s)),
        }
    } else {
        Err(String::from("Invalid UTF-8 in number"))
    }
}

fn parse_array(chars: &mut Peekable<Chars>, depth: usize) -> Result<JsonValue, String> {
    chars.next(); // consume '['
    let mut arr = Vec::new();
    skip_whitespace(chars);
    if chars.peek() == Some(&']') {
        chars.next();
        return Ok(JsonValue::Array(arr));
    }
    loop {
        arr.push(parse_value(chars, depth + 1)?);
        skip_whitespace(chars);
        match chars.next() {
            Some(',') => continue,
            Some(']') => break,
            _ => return Err(String::from("Expected ',' or ']' in array")),
        }
    }
    Ok(JsonValue::Array(arr))
}

fn parse_object(chars: &mut Peekable<Chars>, depth: usize) -> Result<JsonValue, String> {
    chars.next(); // consume '{'
    let mut obj = BTreeMap::new();
    skip_whitespace(chars);
    if chars.peek() == Some(&'}') {
        chars.next();
        return Ok(JsonValue::Object(obj));
    }
    loop {
        skip_whitespace(chars);
        if chars.peek() != Some(&'"') {
            return Err(String::from("Expected string key in object"));
        }
        let key = parse_string(chars)?;
        skip_whitespace(chars);
        if chars.next() != Some(':') {
            return Err(String::from("Expected ':' after key"));
        }
        let val = parse_value(chars, depth + 1)?;
        obj.insert(key, val);
        skip_whitespace(chars);
        match chars.next() {
            Some(',') => continue,
            Some('}') => break,
            _ => return Err(String::from("Expected ',' or '}' in object")),
        }
    }
    Ok(JsonValue::Object(obj))
}

pub fn to_string(value: &JsonValue) -> String {
    let mut out = String::new();
    stringify_to(value, &mut out);
    out
}

pub fn stringify_to(value: &JsonValue, out: &mut String) {
    match value {
        JsonValue::Null => out.push_str("null"),
        JsonValue::Bool(true) => out.push_str("true"),
        JsonValue::Bool(false) => out.push_str("false"),
        JsonValue::Number(n) => {
            use core::fmt::Write;
            let _ = write!(out, "{}", n);
        }
        JsonValue::String(s) => {
            out.push('"');
            for c in s.chars() {
                match c {
                    '"' => out.push_str("\\\""),
                    '\\' => out.push_str("\\\\"),
                    '\n' => out.push_str("\\n"),
                    '\r' => out.push_str("\\r"),
                    '\t' => out.push_str("\\t"),
                    c => out.push(c),
                }
            }
            out.push('"');
        }
        JsonValue::Array(arr) => {
            out.push('[');
            for (i, v) in arr.iter().enumerate() {
                if i > 0 {
                    out.push_str(", ");
                }
                stringify_to(v, out);
            }
            out.push(']');
        }
        JsonValue::Object(obj) => {
            out.push('{');
            let mut first = true;
            for (k, v) in obj.iter() {
                if !first {
                    out.push_str(", ");
                }
                first = false;
                out.push('"');
                out.push_str(k);
                out.push_str("\": ");
                stringify_to(v, out);
            }
            out.push('}');
        }
    }
}