zshrs 0.11.18

//! Langinfo module — port of `Src/Modules/langinfo.c`.
//!
//! C source has zero `struct ...` / `enum ...` definitions. Rust
//! port matches: zero types. Three substantive functions
//! (`liitem`, `getlanginfo`, `scanlanginfo`) plus the 6 module
//! loaders.
//!
//! Provides the `${langinfo[NAME]}` magic-assoc backed by libc
//! `nl_langinfo(3)`.

/// `nl_names[]` — port of the static name-array at `langinfo.c:65`.
/// Each entry pairs with the parallel `nl_vals[]` array of `nl_item`
/// integer keys. Used by `liitem()` for name→item lookup and by
/// `scanlanginfo()` to enumerate every entry.
use std::ffi::CStr;
use std::sync::{Mutex, OnceLock};
use crate::ported::zsh_h::features;
use crate::utils::unmetafy;
use crate::zsh_h::module;

/// Port of `liitem(const char *name)` from `Src/Modules/langinfo.c:379`. Walks the
/// parallel `nl_names[]` / `nl_vals[]` arrays looking for `name`;
/// returns the nl_item integer when found, None otherwise.
///
/// C signature: `static nl_item *liitem(const char *name)`.
/// Rust port collapses C's pointer return to `Option<libc::nl_item>`
/// — the C call sites only need the integer value, never write
/// through the pointer.
/// Parallel `(nl_names[], nl_vals[])` arrays from
/// `langinfo.c:65,235` — paired here to keep liitem's body a
/// faithful loop-over-arrays match for C.
#[cfg(unix)]
static NL_TABLE: &[(&str, libc::nl_item)] = &[
    // c:65,235
    ("CODESET", libc::CODESET),
    ("D_T_FMT", libc::D_T_FMT),
    ("D_FMT", libc::D_FMT),
    ("T_FMT", libc::T_FMT),
    ("RADIXCHAR", libc::RADIXCHAR),
    ("THOUSEP", libc::THOUSEP),
    ("YESEXPR", libc::YESEXPR),
    ("NOEXPR", libc::NOEXPR),
    #[cfg(target_os = "linux")]
    ("CRNCYSTR", libc::CRNCYSTR),
    ("ABDAY_1", libc::ABDAY_1),
    ("ABDAY_2", libc::ABDAY_2),
    ("ABDAY_3", libc::ABDAY_3),
    ("ABDAY_4", libc::ABDAY_4),
    ("ABDAY_5", libc::ABDAY_5),
    ("ABDAY_6", libc::ABDAY_6),
    ("ABDAY_7", libc::ABDAY_7),
    ("DAY_1", libc::DAY_1),
    ("DAY_2", libc::DAY_2),
    ("DAY_3", libc::DAY_3),
    ("DAY_4", libc::DAY_4),
    ("DAY_5", libc::DAY_5),
    ("DAY_6", libc::DAY_6),
    ("DAY_7", libc::DAY_7),
    ("ABMON_1", libc::ABMON_1),
    ("ABMON_2", libc::ABMON_2),
    ("ABMON_3", libc::ABMON_3),
    ("ABMON_4", libc::ABMON_4),
    ("ABMON_5", libc::ABMON_5),
    ("ABMON_6", libc::ABMON_6),
    ("ABMON_7", libc::ABMON_7),
    ("ABMON_8", libc::ABMON_8),
    ("ABMON_9", libc::ABMON_9),
    ("ABMON_10", libc::ABMON_10),
    ("ABMON_11", libc::ABMON_11),
    ("ABMON_12", libc::ABMON_12),
    ("MON_1", libc::MON_1),
    ("MON_2", libc::MON_2),
    ("MON_3", libc::MON_3),
    ("MON_4", libc::MON_4),
    ("MON_5", libc::MON_5),
    ("MON_6", libc::MON_6),
    ("MON_7", libc::MON_7),
    ("MON_8", libc::MON_8),
    ("MON_9", libc::MON_9),
    ("MON_10", libc::MON_10),
    ("MON_11", libc::MON_11),
    ("MON_12", libc::MON_12),
    ("T_FMT_AMPM", libc::T_FMT_AMPM),
    ("AM_STR", libc::AM_STR),
    ("PM_STR", libc::PM_STR),
    ("ERA", libc::ERA),
    ("ERA_D_FMT", libc::ERA_D_FMT),
    ("ERA_D_T_FMT", libc::ERA_D_T_FMT),
    ("ERA_T_FMT", libc::ERA_T_FMT),
    ("ALT_DIGITS", libc::ALT_DIGITS),
];

#[cfg(unix)]
pub fn liitem(name: &str) -> Option<libc::nl_item> {
    // c:379
    NL_TABLE.iter().find(|(n, _)| *n == name).map(|(_, v)| *v) // c:386 strcmp
}

/// Port of `liitem(const char *name)` from `Src/Modules/langinfo.c:379`.
/// Non-Unix fallback for `liitem` — `nl_item` is POSIX-only.
#[cfg(not(unix))]
#[allow(unused_variables)]
pub fn liitem(name: &str) -> Option<i32> {
    // c:379
    None
}

/// Port of `getlanginfo(UNUSED(HashTable ht), const char *name)` from `Src/Modules/langinfo.c:396`. The
/// magic-assoc lookup callback for `${langinfo[NAME]}`. Looks up
/// `name` via `liitem`, runs `nl_langinfo(*elem)`, and returns
/// the resulting locale string (or `None` for unset).
///
/// C signature: `static HashNode getlanginfo(HashTable ht,
///                                            const char *name)`.
/// Rust port returns `Option<String>` matching the observable
/// "u.str + PM_UNSET" duality C builds into the Param node.
#[cfg(unix)]
/// WARNING: param names don't match C — Rust=(name) vs C=(ht, name)
pub fn getlanginfo(name: &str) -> Option<String> {
    // c:396
    // c:403-404 — `nameu = dupstring(name); unmetafy(nameu, &len);`
    let mut buf = name.as_bytes().to_vec(); // c:403
    unmetafy(&mut buf); // c:404
    let nameu = std::str::from_utf8(&buf).ok()?;
    // c:411-415 — `if (name) elem = liitem(name); else elem = NULL;`
    let elem = liitem(nameu)?; // c:412
    unsafe {
        // c:416 — `listr = nl_langinfo(*elem)`.
        let ptr = libc::nl_langinfo(elem); // c:416
        if ptr.is_null() {
            return None; // c:421 PM_UNSET
        }
        let s = CStr::from_ptr(ptr).to_string_lossy().into_owned();
        if s.is_empty() {
            // c:421 — empty result also flags PM_UNSET.
            return None;
        }
        Some(s) // c:417 dupstring (no metafy — C uses dupstring not metafy here)
    }
}

/// Port of `getlanginfo(UNUSED(HashTable ht), const char *name)` from `Src/Modules/langinfo.c:396`.
/// Non-Unix fallback for `getlanginfo` — `nl_langinfo(3)` is
/// POSIX-only.
#[cfg(not(unix))]
/// WARNING: param names don't match C — Rust=(_name) vs C=(ht, name)
pub fn getlanginfo(_name: &str) -> Option<String> {
    // c:396
    None
}

/// Port of `scanlanginfo(UNUSED(HashTable ht), ScanFunc func, int flags)` from `Src/Modules/langinfo.c:430`. The
/// magic-assoc scan callback for `${(k)langinfo}` /
/// `${(kv)langinfo}`. Walks the `nl_names[]` array, calls
/// `nl_langinfo` for each entry, and yields every (name, value)
/// pair where the value is non-NULL.
///
/// C signature: `static void scanlanginfo(HashTable ht, ScanFunc
///                                         func, int flags)`.
/// Rust port returns the (name, value) pairs as a Vec since the
/// callback-driven C API doesn't translate cleanly.
/// WARNING: param names don't match C — Rust=() vs C=(ht, func, flags)
pub fn scanlanginfo() -> Vec<(String, String)> {
    // c:430
    let mut out = Vec::new();
    for &name in NL_NAMES {
        // c:444 walk nl_names
        if let Some(v) = getlanginfo(name) {
            // c:446 nl_langinfo
            out.push((name.to_string(), v)); // c:451 emit
        }
    }
    out
}

// `partab` — port of `static struct paramdef partab[]` (langinfo.c:455).

// `module_features` — port of `static struct features module_features`
// from langinfo.c:464.

/// Port of `setup_(UNUSED(Module m))` from `Src/Modules/langinfo.c:472`.
#[allow(unused_variables)]
pub fn setup_(m: *const module) -> i32 {
    // c:472
    0 // c:487
}

// =====================================================================
// static struct paramdef partab[]                                   c:455
// static struct features module_features                            c:464
// =====================================================================

/// Port of `features_(UNUSED(Module m), UNUSED(char ***features))` from `Src/Modules/langinfo.c:479`.
/// C body: `*features = featuresarray(m, &module_features); return 0;`
pub fn features_(m: *const module, features: &mut Vec<String>) -> i32 {
    // c:479
    *features = featuresarray(m, module_features());
    0 // c:494
}

/// Port of `enables_(UNUSED(Module m), UNUSED(int **enables))` from `Src/Modules/langinfo.c:487`.
/// C body: `return handlefeatures(m, &module_features, enables);`
pub fn enables_(m: *const module, enables: &mut Option<Vec<i32>>) -> i32 {
    // c:487
    handlefeatures(m, module_features(), enables) // c:501
}

/// Port of `boot_(UNUSED(Module m))` from `Src/Modules/langinfo.c:494`.
#[allow(unused_variables)]
pub fn boot_(m: *const module) -> i32 {
    // c:494
    0 // c:508
}

/// Port of `cleanup_(UNUSED(Module m))` from `Src/Modules/langinfo.c:501`.
/// C body: `return setfeatureenables(m, &module_features, NULL);`
pub fn cleanup_(m: *const module) -> i32 {
    // c:501
    setfeatureenables(m, module_features(), None) // c:508
}

/// Port of `finish_(UNUSED(Module m))` from `Src/Modules/langinfo.c:508`.
#[allow(unused_variables)]
pub fn finish_(m: *const module) -> i32 {
    // c:508
    0 // c:508
}
pub static NL_NAMES: &[&str] = &[
    // c:65 nl_names
    "CODESET",
    "D_T_FMT",
    "D_FMT",
    "T_FMT",
    "RADIXCHAR",
    "THOUSEP",
    "YESEXPR",
    "NOEXPR",
    "CRNCYSTR",
    "ABDAY_1",
    "ABDAY_2",
    "ABDAY_3",
    "ABDAY_4",
    "ABDAY_5",
    "ABDAY_6",
    "ABDAY_7",
    "DAY_1",
    "DAY_2",
    "DAY_3",
    "DAY_4",
    "DAY_5",
    "DAY_6",
    "DAY_7",
    "ABMON_1",
    "ABMON_2",
    "ABMON_3",
    "ABMON_4",
    "ABMON_5",
    "ABMON_6",
    "ABMON_7",
    "ABMON_8",
    "ABMON_9",
    "ABMON_10",
    "ABMON_11",
    "ABMON_12",
    "MON_1",
    "MON_2",
    "MON_3",
    "MON_4",
    "MON_5",
    "MON_6",
    "MON_7",
    "MON_8",
    "MON_9",
    "MON_10",
    "MON_11",
    "MON_12",
    "T_FMT_AMPM",
    "AM_STR",
    "PM_STR",
    "ERA",
    "ERA_D_FMT",
    "ERA_D_T_FMT",
    "ERA_T_FMT",
    "ALT_DIGITS",
];


static MODULE_FEATURES: OnceLock<Mutex<features>> = OnceLock::new();

// Local stubs for the per-module entry points. C uses generic
// `featuresarray`/`handlefeatures`/`setfeatureenables` (module.c:
// 3275/3370/3445) but those take `Builtin` + `Features` pointer
// fields the Rust port doesn't carry. The hardcoded descriptor
// list mirrors the C bintab/conddefs/mathfuncs/paramdefs.
// WARNING: NOT IN LANGINFO.C — Rust-only module-framework shim.
// C uses generic featuresarray/handlefeatures/setfeatureenables from
// Src/module.c:3275/3370/3445 with C-side Builtin/Features pointers;
// Rust per-module shims hardcode the bintab/conddefs/mathfuncs/paramdefs.
fn featuresarray(_m: *const module, _f: &Mutex<features>) -> Vec<String> {
    vec!["p:langinfo".to_string()]
}

// WARNING: NOT IN LANGINFO.C — Rust-only module-framework shim.
// C uses generic featuresarray/handlefeatures/setfeatureenables from
// Src/module.c:3275/3370/3445 with C-side Builtin/Features pointers;
// Rust per-module shims hardcode the bintab/conddefs/mathfuncs/paramdefs.
fn handlefeatures(
    _m: *const module,
    _f: &Mutex<features>,
    enables: &mut Option<Vec<i32>>,
) -> i32 {
    if enables.is_none() {
        *enables = Some(vec![1; 1]);
    }
    0
}

// WARNING: NOT IN LANGINFO.C — Rust-only module-framework shim.
// C uses generic featuresarray/handlefeatures/setfeatureenables from
// Src/module.c:3275/3370/3445 with C-side Builtin/Features pointers;
// Rust per-module shims hardcode the bintab/conddefs/mathfuncs/paramdefs.
fn setfeatureenables(_m: *const module, _f: &Mutex<features>, _e: Option<&[i32]>) -> i32 {
    0
}

// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// ─── RUST-ONLY ACCESSORS ───
//
// Singleton accessor ported for `OnceLock<Mutex<T>>` / `OnceLock<
// RwLock<T>>` globals declared above. C zsh uses direct global
// access; Rust needs these wrappers because `OnceLock::get_or_init`
// is the only way to lazily construct shared state. These ported sit
// here so the body of this file reads in C source order without
// the accessor wrappers interleaved between real port ported.
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// ─── RUST-ONLY ACCESSORS ───
//
// Singleton accessor ported for `OnceLock<Mutex<T>>` / `OnceLock<
// RwLock<T>>` globals declared above. C zsh uses direct global
// access; Rust needs these wrappers because `OnceLock::get_or_init`
// is the only way to lazily construct shared state. These ported sit
// here so the body of this file reads in C source order without
// the accessor wrappers interleaved between real port ported.
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

// WARNING: NOT IN LANGINFO.C — Rust-only module-framework shim.
// C uses generic featuresarray/handlefeatures/setfeatureenables from
// Src/module.c:3275/3370/3445 with C-side Builtin/Features pointers;
// Rust per-module shims hardcode the bintab/conddefs/mathfuncs/paramdefs.
fn module_features() -> &'static Mutex<features> {
    MODULE_FEATURES.get_or_init(|| {
        Mutex::new(features {
            bn_list: None,
            bn_size: 0,
            cd_list: None,
            cd_size: 0,
            mf_list: None,
            mf_size: 0,
            pd_list: None,
            pd_size: 1,
            n_abstract: 0,
        })
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn nl_names_includes_codeset() {
        let _g = crate::test_util::global_state_lock();
        assert!(NL_NAMES.contains(&"CODESET"));
        assert!(NL_NAMES.contains(&"D_T_FMT"));
    }

    #[cfg(unix)]
    #[test]
    fn getlanginfo_codeset_is_some() {
        let _g = crate::test_util::global_state_lock();
        assert!(getlanginfo("CODESET").is_some());
    }

    #[test]
    fn getlanginfo_invalid_returns_none() {
        let _g = crate::test_util::global_state_lock();
        assert!(getlanginfo("INVALID_NAME").is_none());
    }

    #[cfg(unix)]
    #[test]
    fn liitem_codeset_resolves() {
        let _g = crate::test_util::global_state_lock();
        assert!(liitem("CODESET").is_some());
        assert!(liitem("DOES_NOT_EXIST").is_none());
    }

    #[cfg(unix)]
    #[test]
    fn scanlanginfo_emits_items() {
        let _g = crate::test_util::global_state_lock();
        let v = scanlanginfo();
        assert!(!v.is_empty());
        assert!(v.iter().any(|(k, _)| k == "CODESET"));
    }

    /// c:65 — `nl_names` is the authoritative table of every POSIX
    /// nl_item name. Verify the set includes every category the
    /// langinfo(3) spec lists, not just CODESET. A regression that
    /// truncates the table would silently break `$(getlanginfo D_FMT)`
    /// and similar lookups in user scripts.
    #[test]
    fn nl_names_covers_canonical_locale_items() {
        let _g = crate::test_util::global_state_lock();
        for required in [
            "CODESET",
            "D_T_FMT",
            "D_FMT",
            "T_FMT",
            "T_FMT_AMPM",
            "AM_STR",
            "PM_STR",
            "DAY_1",
            "DAY_7",
            "ABDAY_1",
            "MON_1",
            "MON_12",
            "RADIXCHAR",
            "THOUSEP",
            "YESEXPR",
            "NOEXPR",
        ] {
            assert!(
                NL_NAMES.contains(&required),
                "NL_NAMES missing {} — port table truncated?",
                required
            );
        }
    }

    /// c:65 — every entry in NL_NAMES must be a valid nl_item name
    /// per langinfo.h: ALL_CAPS_WITH_UNDERSCORES, no leading digit.
    /// Pinning the shape catches a regression that adds spaces or
    /// lowercase entries (which would silently fail `getlanginfo` on
    /// the user-facing builtin path).
    #[test]
    fn nl_names_entries_are_uppercase_identifiers() {
        let _g = crate::test_util::global_state_lock();
        for &n in NL_NAMES {
            assert!(!n.is_empty(), "empty entry in NL_NAMES");
            assert!(
                n.chars()
                    .all(|c| c.is_ascii_uppercase() || c.is_ascii_digit() || c == '_'),
                "NL_NAMES entry {:?} contains non-uppercase chars",
                n
            );
            assert!(
                !n.starts_with(|c: char| c.is_ascii_digit()),
                "NL_NAMES entry {:?} starts with a digit",
                n
            );
        }
    }

    /// c:65 — NL_NAMES must not have duplicate entries. The C source
    /// preserves the LC_* category groupings; an accidental duplicate
    /// would silently double-emit in `scanlanginfo`.
    #[test]
    fn nl_names_has_no_duplicates() {
        let _g = crate::test_util::global_state_lock();
        let unique: std::collections::HashSet<_> = NL_NAMES.iter().copied().collect();
        assert_eq!(unique.len(), NL_NAMES.len(), "duplicate entry in NL_NAMES");
    }

    /// c:430 — `scanlanginfo` keys must be a subset of NL_NAMES.
    /// (The C source walks `nl_names` in order.) Anything extra
    /// would indicate a parallel hardcoded list drifted out of sync
    /// with the canonical table.
    #[cfg(unix)]
    #[test]
    fn scanlanginfo_keys_are_subset_of_nl_names() {
        let _g = crate::test_util::global_state_lock();
        for (k, _) in scanlanginfo() {
            assert!(
                NL_NAMES.contains(&k.as_str()),
                "scanlanginfo emitted {:?} which is not in NL_NAMES",
                k
            );
        }
    }

    /// c:396 — `getlanginfo` is case-sensitive: lowercase input must
    /// not match the uppercase canonical name. Catches a regression
    /// that adds a `.to_uppercase()` for "convenience".
    #[cfg(unix)]
    #[test]
    fn getlanginfo_is_case_sensitive() {
        let _g = crate::test_util::global_state_lock();
        assert!(getlanginfo("CODESET").is_some());
        assert!(
            getlanginfo("codeset").is_none(),
            "getlanginfo must be case-sensitive per the C source's strcmp lookup"
        );
    }

    /// c:472-510 — module-lifecycle stubs all return 0 in C.
    #[test]
    fn module_lifecycle_shims_all_return_zero() {
        let _g = crate::test_util::global_state_lock();
        let m: *const crate::ported::zsh_h::module = std::ptr::null();
        assert_eq!(setup_(m), 0);
        assert_eq!(boot_(m), 0);
        assert_eq!(cleanup_(m), 0);
        assert_eq!(finish_(m), 0);
    }

    // ─── zsh-corpus pins ────────────────────────────────────────────

    /// `liitem("CODESET")` returns Some (POSIX `nl_item` standard key).
    #[test]
    fn langinfo_corpus_codeset_is_known() {
        let _g = crate::test_util::global_state_lock();
        assert!(liitem("CODESET").is_some(),
            "CODESET is a POSIX-standard nl_item key");
    }

    /// `liitem("DAY_1")` returns Some (POSIX day name).
    #[test]
    fn langinfo_corpus_day_1_is_known() {
        let _g = crate::test_util::global_state_lock();
        assert!(liitem("DAY_1").is_some(),
            "DAY_1 is a POSIX-standard nl_item key");
    }

    /// `liitem("RADIXCHAR")` is known.
    #[test]
    fn langinfo_corpus_radixchar_is_known() {
        let _g = crate::test_util::global_state_lock();
        assert!(liitem("RADIXCHAR").is_some());
    }

    /// `liitem("BOGUS_NOT_REAL_KEY")` returns None.
    #[test]
    fn langinfo_corpus_unknown_key_returns_none() {
        let _g = crate::test_util::global_state_lock();
        assert!(liitem("BOGUS_NOT_REAL_KEY").is_none());
        assert!(liitem("").is_none());
    }

    /// `getlanginfo("CODESET")` returns a non-empty string (system locale).
    #[test]
    fn langinfo_corpus_getlanginfo_codeset_nonempty() {
        let _g = crate::test_util::global_state_lock();
        let r = getlanginfo("CODESET");
        assert!(r.is_some(), "CODESET resolves to a string");
        let s = r.unwrap();
        assert!(!s.is_empty(), "CODESET non-empty (e.g. 'UTF-8'), got {s:?}");
    }

    /// `scanlanginfo` returns non-empty list (system has known keys).
    #[test]
    fn langinfo_corpus_scanlanginfo_returns_entries() {
        let _g = crate::test_util::global_state_lock();
        let entries = scanlanginfo();
        assert!(!entries.is_empty(),
            "scanlanginfo should return some entries");
    }
}