zshrs 0.11.18

//! Module system for zshrs
//!
//! Port from zsh/Src/module.c (3,646 lines)
//!
//! Hash of modules                                                          // c:46
//! The list of hook functions defined.                                      // c:840
//! List of math functions.                                                  // c:1255
//!
//! In C, module.c provides dynamic loading of .so modules at runtime
//! via dlopen/dlsym. In Rust, all modules are statically compiled into
//! the binary — there's no dynamic loading. This module provides the
//! registration, lookup, and management API that the rest of the shell
//! uses to interact with module features (builtins, conditions, parameters,
//! hooks, and math functions).

use crate::ported::builtin::createbuiltintable;
use crate::ported::params::{createparam, createspecialhash, paramtab, unsetparam_pm};
use crate::ported::signals::unqueue_signals;
use crate::ported::utils::{zwarn, zwarnnam};
use crate::ported::zsh_h::{BINF_AUTOALL, CONDF_AUTOALL, HOOKF_ALL, Hookfn, MFF_USERFUNC, MOD_ALIAS, MOD_BUSY, MOD_INIT_B, MOD_INIT_S, MOD_LINKED, MOD_SETUP, MOD_UNLOAD, OPT_ISSET, PM_ARRAY, PM_AUTOLOAD, PM_EFLOAT, PM_FFLOAT, PM_HASHED, PM_INTEGER, PM_NAMEREF, PM_READONLY, PM_REMOVABLE, PM_SCALAR, PM_TIED, PM_TYPE, builtin, conddef, funcwrap, hookdef, mathfunc, options, paramdef, CASMOD_LOWER, CASMOD_UPPER, Param, linknode, linklist, PM_AUTOALL, PRINT_LIST};
use crate::zsh_h::module;
use once_cell::sync::Lazy;
use std::collections::HashMap;
use std::sync::Mutex;
use crate::ported::hist::casemodify;
use crate::ported::mem::ztrdup;
pub use crate::ported::zsh_h::{BINF_ADDED, CONDF_ADDED, CONDF_INFIX, MFF_ADDED};


/// Free module node (from module.c freemodulenode)
/// Free a module table entry.
/// Port of `freemodulenode(HashNode hn)` from Src/module.c:119 — Rust's
/// `Drop` handles the per-field free; this exists for API
/// parity with C callers.
pub fn freemodulenode(hn: module) {
    // Rust Drop handles this
}

/// `PRINTMOD_LIST` from `Src/module.c:136`. Long-form (`zmodload -L`)
/// output.
pub const PRINTMOD_LIST: i32 = 0x0001; // c:136
/// `PRINTMOD_EXIST` from `Src/module.c:138`. Print only when the
/// module exists.
pub const PRINTMOD_EXIST: i32 = 0x0002; // c:138
/// `PRINTMOD_ALIAS` from `Src/module.c:140`. Resolve aliases when
/// emitting under `PRINTMOD_EXIST`.
pub const PRINTMOD_ALIAS: i32 = 0x0004; // c:140
/// `PRINTMOD_DEPS` from `Src/module.c:142`. Emit the dependency list
/// (`zmodload -d`).
pub const PRINTMOD_DEPS: i32 = 0x0008; // c:142
/// `PRINTMOD_FEATURES` from `Src/module.c:144`. Emit feature flags
/// (`zmodload -F`).
pub const PRINTMOD_FEATURES: i32 = 0x0010; // c:144
/// `PRINTMOD_LISTALL` from `Src/module.c:146`. Include disabled
/// features (`zmodload -lL`).
pub const PRINTMOD_LISTALL: i32 = 0x0020; // c:146
/// `PRINTMOD_AUTO` from `Src/module.c:148`. Emit autoloads
/// (`zmodload -a`).
pub const PRINTMOD_AUTO: i32 = 0x0040; // c:148

/// Direct port of `void printmodulenode(HashNode hn, int flags)` from
/// `Src/module.c:154`.
///
/// Formats one module entry for the various `zmodload -L`/`-a`/
/// `-d`/`-F` listings. C writes to stdout; Rust returns the
/// formatted string so call sites can route to the right output fd
/// without depending on stdio. Dispatches on `flags`:
///
///   - `PRINTMOD_DEPS`: emit dep list (`zmodload -d MOD: dep1 dep2`
///     under PRINTMOD_LIST, else `MOD: dep1 dep2`) — c:163-194
///   - `PRINTMOD_EXIST`: emit just the module name when loaded
///     (resolving alias when PRINTMOD_ALIAS set) — c:195-201
///   - alias module: under PRINTMOD_LIST emit
///     `zmodload -A MOD=ALIAS`, else `MOD -> ALIAS` — c:202-217
///   - loaded module: under PRINTMOD_LIST emit `zmodload [-Fa] MOD`,
///     else just the name — c:218-241
pub fn printmodulenode(hn: &str, m: &module, flags: i32) -> String {
    let modname = hn;
    let mut out = String::new();

    // c:163-194 — PRINTMOD_DEPS branch.
    if flags & PRINTMOD_DEPS != 0 {
        let deps = match m.deps.as_ref() {
            Some(d) if !d.is_empty() => d,
            _ => return out,
        };
        if flags & PRINTMOD_LIST != 0 {
            out.push_str("zmodload -d ");
            if modname.starts_with('-') {
                out.push_str("-- ");
            }
            out.push_str(modname);
        } else {
            out.push_str(modname);
            out.push(':');
        }
        for dep in deps.iter() {
            out.push(' ');
            out.push_str(dep);
        }
        return out;
    }

    // c:195-201 — PRINTMOD_EXIST branch.
    if flags & PRINTMOD_EXIST != 0 {
        if (m.node.flags & MOD_ALIAS) != 0
            && (flags & PRINTMOD_ALIAS == 0 || m.alias.is_none())
        {
            return out;
        }
        if m.node.flags & MOD_UNLOAD != 0 {
            return out;
        }
        out.push_str(modname);
        return out;
    }

    // c:202-217 — alias module branch.
    if m.node.flags & MOD_ALIAS != 0 {
        let alias = m.alias.as_deref().unwrap_or("");
        if flags & PRINTMOD_LIST != 0 {
            out.push_str("zmodload -A ");
            if modname.starts_with('-') {
                out.push_str("-- ");
            }
            out.push_str(modname);
            out.push('=');
            out.push_str(alias);
        } else {
            out.push_str(modname);
            out.push_str(" -> ");
            out.push_str(alias);
        }
        return out;
    }

    // c:218-241 — loaded module branch (linked or autoloaded).
    let loaded = (m.node.flags & MOD_LINKED) != 0 && (m.node.flags & MOD_UNLOAD) == 0;
    let auto = flags & PRINTMOD_AUTO != 0;
    if loaded || auto {
        if flags & PRINTMOD_LIST != 0 {
            out.push_str("zmodload ");
            if auto {
                out.push_str("-Fa ");
            } else if flags & PRINTMOD_FEATURES != 0 {
                out.push_str("-F ");
            }
            if modname.starts_with('-') {
                out.push_str("-- ");
            }
            out.push_str(modname);
        } else {
            out.push_str(modname);
        }
    }
    out
}

/// Create new module table (from module.c newmoduletable)
/// Create an empty module table.
/// Port of `newmoduletable(int size, char const *name)` from Src/module.c:274 — the C
/// source allocates the `modulestab` hash with `createhashtable`.
/// WARNING: param names don't match C — Rust=() vs C=(size, name)
pub fn newmoduletable() -> modulestab {
    modulestab::new()
}

/// Port of `setup_(UNUSED(Module m))` from `Src/module.c:306`.
///
/// C body: `setup_(UNUSED(Module m)) { return 0; }` — the no-op
/// setup hook of the module subsystem itself.
#[allow(unused_variables)]
pub fn setup_(m: *const module) -> i32 {
    // c:306
    0 // c:306
}

/// Port of `features_(UNUSED(Module m), UNUSED(char ***features))` from `Src/module.c:313`.
///
/// C body:
/// ```c
/// features_(UNUSED(Module m), UNUSED(char ***features))
/// {
///     /* There are lots and lots of features, but they're not handled here. */
///     return 1;
/// }
/// ```
#[allow(unused_variables)]
pub fn features_(m: *const module, features: &mut Vec<String>) -> i32 {
    // c:313
    /* There are lots and lots of features, but they're not handled here. */ // c:313-318
    1 // c:319
}

/// Port of `enables_(UNUSED(Module m), UNUSED(int **enables))` from `Src/module.c:324`.
///
/// C body: `enables_(UNUSED(Module m), UNUSED(int **enables)) { return 1; }`
/// — the module subsystem itself doesn't manage feature enables.
#[allow(unused_variables)]
pub fn enables_(m: *const module, enables: &mut Option<Vec<i32>>) -> i32 {
    // c:324
    1 // c:324
}

/// Port of `boot_(UNUSED(Module m))` from `Src/module.c:331`.
///
/// C body: `boot_(UNUSED(Module m)) { return 0; }` — the no-op
/// boot hook of the module subsystem itself.
#[allow(unused_variables)]
pub fn boot_(m: *const module) -> i32 {
    // c:331
    0 // c:331
}

/// Port of `cleanup_(UNUSED(Module m))` from `Src/module.c:338`.
///
/// C body: `cleanup_(UNUSED(Module m)) { return 0; }` — the no-op
/// cleanup hook of the module subsystem itself.
#[allow(unused_variables)]
pub fn cleanup_(m: *const module) -> i32 {
    // c:338
    0 // c:338
}

/// Port of `finish_(UNUSED(Module m))` from `Src/module.c:345`.
///
/// C body: `finish_(UNUSED(Module m)) { return 0; }` —
/// the no-op finish hook for the module subsystem itself.
#[allow(unused_variables)]
pub fn finish_(m: *const module) -> i32 {
    // c:345
    0 // c:345
}

// This registers a builtin module.                                        // c:359
/// Register module (from module.c register_module)
/// Register a module by name.
/// Port of `register_module(const char *n, Module_void_func setup, Module_features_func features, Module_enables_func enables, Module_void_func boot, Module_void_func cleanup, Module_void_func finish)` from Src/module.c:359 — wraps
/// a slot in the global `modulestab` and seeds its lifecycle
/// callbacks.
/// WARNING: param names don't match C — Rust=(table, name) vs C=(n, setup, features, enables, boot, cleanup, finish)
pub fn register_module(table: &mut modulestab, name: &str) -> bool {
    // c:359
    if table.modules.contains_key(name) {
        return false;
    }
    table.modules.insert(name.to_string(), module::new(name));
    true
}

/// Port of `addbuiltins(char const *nam, Builtin binl, int size)` from `Src/module.c:544`.
///
/// C body:
/// ```c
/// addbuiltins(char const *nam, Builtin binl, int size)
/// {
///     int ret = 0, n;
///     for(n = 0; n < size; n++) {
///         Builtin b = &binl[n];
///         if(b->node.flags & BINF_ADDED)
///             continue;
///         if(addbuiltin(b)) {
///             zwarnnam(nam, "name clash when adding builtin `%s'", b->node.nam);
///             ret = 1;
///         } else {
///             b->node.flags |= BINF_ADDED;
///         }
///     }
///     return ret;
/// }
/// ```
///
/// Rust port: walks the slice, checks BINF_ADDED, registers via the
/// module-table addbuiltin if not already registered. `binl` is taken
/// by `&mut [Builtin]` so the BINF_ADDED flag-set after success
/// matches C's in-place mutation.
/// Port of `addbuiltin(Builtin b)` from `Src/module.c:524`. C body:
/// look up `b->node.nam` in builtintab; if BINF_ADDED clash → return 1;
/// otherwise replace any pre-existing entry and add `b`. Returns 0 on
/// add, 1 on clash.
///
/// The Rust canonical builtintab is `OnceLock<HashMap<String,
/// &'static builtin>>` — immutable after first access. Runtime `addbuiltin`
/// calls check the immutable table for the clash gate; the BINF_ADDED
/// flag-set on the input record is what callers observe (matching the
/// C in-place mutation that `addbuiltins` then propagates).
pub fn addbuiltin(b: &mut builtin) -> i32 {
    // c:524
    let tab = createbuiltintable();
    if let Some(existing) = tab.get(&b.node.nam) {
        // c:526 getnode2
        if (existing.node.flags & BINF_ADDED as i32) != 0 {
            return 1;
        } // c:527 clash
    }
    b.node.flags |= BINF_ADDED as i32; // c:531 b->node.flags |= BINF_ADDED
    0
}

/// Port of `addbuiltins(char const *nam, Builtin binl, int size)` from
/// `Src/module.c:544`. Walks the slice; for each entry not already
/// flagged BINF_ADDED, calls `addbuiltin`. Returns 0 if all succeeded,
/// 1 if any clashed. zwarnnam emitted on each clash matches C.
pub fn addbuiltins(nam: &str, binl: &mut [builtin]) -> i32 {
    // c:544
    let mut ret = 0; // c:548
    for b in binl.iter_mut() {
        // c:550 for(n = 0; n < size; n++)
        if (b.node.flags & BINF_ADDED as i32) != 0 {
            continue;
        } // c:553
        if addbuiltin(b) != 0 {
            // c:555
            zwarnnam(
                nam, // c:556 zwarnnam(nam, "name clash...")
                &format!("name clash when adding builtin `{}'", b.node.nam),
            );
            ret = 1;
        }
    }
    ret // c:563
}

/// Port of `Hookdef gethookdef(const char *n)` from `Src/module.c:849`.
///
/// C body (c:849-861):
/// ```c
/// Hookdef gethookdef(const char *n) {
///     Hookdef p;
///     for (p = hooktab; p; p = p->next)
///         if (!strcmp(n, p->name))
///             return p;
///     return NULL;
/// }
/// ```
pub fn gethookdef(n: &str) -> *mut hookdef {
    // c:849
    let mut p = hooktab.load(std::sync::atomic::Ordering::SeqCst); // c:852 p = hooktab
    while !p.is_null() {
        // c:853
        unsafe {
            if (*p).name == n {
                // c:854 !strcmp
                return p; // c:855
            }
            p = (*p).next; // c:853 p = p->next
        }
    }
    std::ptr::null_mut() // c:856
}

/// Port of `int addhookdef(Hookdef h)` from `Src/module.c:864`.
///
/// C body (c:864-874):
/// ```c
/// int addhookdef(Hookdef h) {
///     if (gethookdef(h->name)) return 1;
///     h->next = hooktab;
///     hooktab = h;
///     h->funcs = znewlinklist();
///     return 0;
/// }
/// ```
pub fn addhookdef(h: *mut hookdef) -> i32 {
    // c:864
    unsafe {
        if !gethookdef(&(*h).name).is_null() {
            // c:866
            return 1; // c:867
        }
        (*h).next = hooktab.load(std::sync::atomic::Ordering::SeqCst); // c:869 h->next = hooktab
        hooktab.store(h, std::sync::atomic::Ordering::SeqCst); // c:870 hooktab = h
        if (*h).funcs.is_null() {
            // c:871 h->funcs = znewlinklist()
            (*h).funcs = Box::into_raw(Box::new(linklist {
                first: None,
                last: None,
                flags: 0,
            }));
        }
    }
    0 // c:873
}

/// Port of `int addhookdefs(Module m, Hookdef h, int size)` from
/// `Src/module.c:883`.
///
/// C body (c:883-895):
/// ```c
/// int addhookdefs(Module m, Hookdef h, int size) {
///     int ret = 0;
///     while (size--) {
///         if (addhookdef(h)) {
///             zwarnnam(m ? m->node.nam : NULL, "name clash when adding hook `%s'", h->name);
///             ret = 1;
///         }
///         h++;
///     }
///     return ret;
/// }
/// ```
pub fn addhookdefs(
    // c:883
    m: *const module,
    mut h: *mut hookdef,
    mut size: i32,
) -> i32 {
    let mut ret: i32 = 0; // c:885
    while size > 0 {
        // c:887 size--
        if addhookdef(h) != 0 {
            // c:888
            let nam: String = if m.is_null() {
                // c:889 m ? m->node.nam : NULL
                String::new()
            } else {
                unsafe { (*m).node.nam.clone() }
            };
            let hook_name = unsafe { (*h).name.clone() };
            zwarnnam(
                // c:889 zwarnnam
                &nam,
                &format!("name clash when adding hook `{}'", hook_name),
            );
            ret = 1; // c:891
        }
        unsafe {
            h = h.add(1);
        } // c:893 h++
        size -= 1; // c:887
    }
    ret // c:894
}

/// Port of `int deletehookdef(Hookdef h)` from `Src/module.c:902`.
///
/// C body (c:902-919):
/// ```c
/// int deletehookdef(Hookdef h) {
///     Hookdef p, q;
///     for (p = hooktab, q = NULL; p && p != h; q = p, p = p->next);
///     if (!p) return 1;
///     if (q) q->next = p->next; else hooktab = p->next;
///     freelinklist(p->funcs, NULL);
///     return 0;
/// }
/// ```
pub fn deletehookdef(h: *mut hookdef) -> i32 {
    // c:902
    let mut p = hooktab.load(std::sync::atomic::Ordering::SeqCst); // c:906 p = hooktab
    let mut q: *mut hookdef = std::ptr::null_mut(); // c:906 q = NULL
    while !p.is_null() && p != h {
        // c:907
        q = p; // c:907 q = p
        unsafe {
            p = (*p).next;
        } // c:907 p = p->next
    }
    if p.is_null() {
        // c:909
        return 1; // c:910
    }
    unsafe {
        if !q.is_null() {
            // c:912
            (*q).next = (*p).next; // c:913 q->next = p->next
        } else {
            hooktab.store((*p).next, std::sync::atomic::Ordering::SeqCst); // c:915 hooktab = p->next
        }
        if !(*p).funcs.is_null() {
            // c:916 freelinklist(p->funcs, NULL)
            drop(Box::from_raw((*p).funcs));
            (*p).funcs = std::ptr::null_mut();
        }
    }
    0 // c:917
}

/// Port of `int deletehookdefs(Module m, Hookdef h, int size)` from
/// `Src/module.c:923`. `m` is unused per `UNUSED(Module m)` in C.
pub fn deletehookdefs(
    // c:923
    _m: *const module,
    mut h: *mut hookdef,
    mut size: i32,
) -> i32 {
    let mut ret: i32 = 0; // c:925
    while size > 0 {
        // c:927 size--
        if deletehookdef(h) != 0 {
            // c:928
            ret = 1; // c:929
        }
        unsafe {
            h = h.add(1);
        } // c:930 h++
        size -= 1; // c:927
    }
    ret // c:931
}

/// Port of `int addhookdeffunc(Hookdef h, Hookfn f)` from `Src/module.c:939`.
///
/// C body (c:939-944):
/// ```c
/// int addhookdeffunc(Hookdef h, Hookfn f) {
///     zaddlinknode(h->funcs, (void *) f);
///     return 0;
/// }
/// ```
pub fn addhookdeffunc(
    // c:939
    h: *mut hookdef,
    f: Hookfn,
) -> i32 {
    unsafe {
        if (*h).funcs.is_null() {
            (*h).funcs = Box::into_raw(Box::new(linklist {
                first: None,
                last: None,
                flags: 0,
            }));
        }
        let funcs = &mut *(*h).funcs;
        // c:942 — zaddlinknode(h->funcs, f) appends to end of LinkList.
        // Walk to tail of owned chain (linklist.last cannot be a Box
        // pointer because that would duplicate ownership of the tail
        // node — the C `last` field is a raw pointer; the Rust
        // representation keeps it as None and resolves the tail by
        // walking forward from .first).
        let new_node = Box::new(linknode {
            next: None,
            prev: None,
            dat: f as usize,
        });
        if funcs.first.is_none() {
            funcs.first = Some(new_node);
        } else {
            let mut tail = funcs.first.as_mut().unwrap();
            while tail.next.is_some() {
                tail = tail.next.as_mut().unwrap();
            }
            tail.next = Some(new_node);
        }
    }
    0 // c:943
}

/// Port of `int addhookfunc(char *n, Hookfn f)` from `Src/module.c:948`.
///
/// C body (c:948-955):
/// ```c
/// int addhookfunc(char *n, Hookfn f) {
///     Hookdef h = gethookdef(n);
///     if (h) return addhookdeffunc(h, f);
///     return 1;
/// }
/// ```
pub fn addhookfunc(
    // c:948
    n: &str,
    f: Hookfn,
) -> i32 {
    let h = gethookdef(n); // c:950 h = gethookdef(n)
    if !h.is_null() {
        // c:951
        return addhookdeffunc(h, f); // c:952
    }
    1 // c:953
}

/// Port of `int deletehookdeffunc(Hookdef h, Hookfn f)` from
/// `Src/module.c:961`.
///
/// C body (c:961-973):
/// ```c
/// int deletehookdeffunc(Hookdef h, Hookfn f) {
///     LinkNode p;
///     for (p = firstnode(h->funcs); p; incnode(p))
///         if (f == (Hookfn) getdata(p)) {
///             remnode(h->funcs, p);
///             return 0;
///         }
///     return 1;
/// }
/// ```
pub fn deletehookdeffunc(
    // c:961
    h: *mut hookdef,
    f: Hookfn,
) -> i32 {
    unsafe {
        if (*h).funcs.is_null() {
            return 1;
        }
        let funcs = &mut *(*h).funcs;
        let f_val = f as usize;
        // Walk owning chain looking for the matching dat. Splice on hit.
        let mut prev: &mut Option<Box<linknode>> = &mut funcs.first;
        loop {
            match prev {
                None => return 1, // c:971
                Some(node) if node.dat == f_val => {
                    // c:966 f == getdata(p)
                    let next = node.next.take(); // c:967 remnode
                    *prev = next;
                    return 0; // c:968
                }
                Some(_) => {
                    // c:965 incnode(p) — advance.
                    prev = &mut prev.as_mut().unwrap().next;
                }
            }
        }
    }
}

/// Port of `int deletehookfunc(const char *n, Hookfn f)` from
/// `Src/module.c:977`.
///
/// C body (c:977-984):
/// ```c
/// int deletehookfunc(const char *n, Hookfn f) {
///     Hookdef h = gethookdef(n);
///     if (h) return deletehookdeffunc(h, f);
///     return 1;
/// }
/// ```
pub fn deletehookfunc(
    // c:977
    n: &str,
    f: Hookfn,
) -> i32 {
    let h = gethookdef(n); // c:979 h = gethookdef(n)
    if !h.is_null() {
        // c:980
        return deletehookdeffunc(h, f); // c:981
    }
    1 // c:982
}

/// Port of `int runhookdef(Hookdef h, void *d)` from `Src/module.c:990`.
///
/// C body (c:990-1010):
/// ```c
/// int runhookdef(Hookdef h, void *d) {
///     if (empty(h->funcs)) {
///         if (h->def) return h->def(h, d);
///         return 0;
///     } else if (h->flags & HOOKF_ALL) {
///         LinkNode p; int r;
///         for (p = firstnode(h->funcs); p; incnode(p))
///             if ((r = ((Hookfn) getdata(p))(h, d))) return r;
///         if (h->def) return h->def(h, d);
///         return 0;
///     } else
///         return ((Hookfn) getdata(lastnode(h->funcs)))(h, d);
/// }
/// ```
pub fn runhookdef(
    // c:990
    h: *mut hookdef,
    d: *mut std::ffi::c_void,
) -> i32 {
    unsafe {
        let funcs_ptr = (*h).funcs;
        let funcs_empty = funcs_ptr.is_null() || (*funcs_ptr).first.is_none(); // c:992 empty()
        if funcs_empty {
            // c:992
            if let Some(def) = (*h).def {
                // c:993 if (h->def)
                return def(h, d); // c:994 return h->def(h,d)
            }
            return 0; // c:995
        }
        if (*h).flags & HOOKF_ALL != 0 {
            // c:996 h->flags & HOOKF_ALL
            let mut node = (*funcs_ptr).first.as_ref(); // c:999 firstnode
            while let Some(n) = node {
                // c:999 ; p ;
                let fn_ptr: Hookfn = std::mem::transmute(n.dat); // c:1000 (Hookfn) getdata(p)
                let r = fn_ptr(h, d); // c:1000 (...)(h, d)
                if r != 0 {
                    // c:1000 if ((r = ...))
                    return r; // c:1001
                }
                node = n.next.as_ref(); // c:999 incnode
            }
            if let Some(def) = (*h).def {
                // c:1002 if (h->def)
                return def(h, d); // c:1003 return h->def(h, d)
            }
            return 0; // c:1004
        }
        // c:1006 — last fn only.
        let mut tail = (*funcs_ptr).first.as_ref().expect("non-empty");
        while let Some(next) = tail.next.as_ref() {
            tail = next;
        }
        let fn_ptr: Hookfn = std::mem::transmute(tail.dat);
        fn_ptr(h, d) // c:1006
    }
}

/// Port of `checkaddparam(const char *nam, int opt_i)` from `Src/module.c:1026`.
///
/// C body:
/// ```c
/// checkaddparam(const char *nam, int opt_i)
/// {
///     Param pm;
///     if (!(pm = (Param) gethashnode2(paramtab, nam)))
///         return 0;
///     if (pm->level || !(pm->node.flags & PM_AUTOLOAD)) {
///         if (!opt_i || pm->level) {
///             zwarn("Can't add module parameter `%s': %s",
///                   nam, pm->level ? "local parameter exists" :
///                                    "parameter already exists");
///             return 1;
///         }
///         return 2;
///     }
///     unsetparam_pm(pm, 0, 1);
///     return 0;
/// }
/// ```
///
/// Returns: 0 = OK to add, 1 = error printed, 2 = blocked but `-i`
/// suppressed warning. `pm->level != 0` means a local param shadows
/// the name (always errors). `PM_AUTOLOAD` set means the existing
/// param is an autoload stub the C source unsets to make room.
///
/// Checks for an existing param of the same name; if absent → 0
/// (free to add). If present and not autoloadable → 1 (warn) or
/// 2 (skip warning under `-i`). If present + autoload-marked →
/// unset the existing entry and return 0.
pub fn checkaddparam(nam: &str, opt_i: i32) -> i32 {
    // c:1026
    // c:1030 — if (!(pm = gethashnode2(paramtab, nam))) return 0;
    let pm_clone = {
        let tab = paramtab()
            .read()
            .expect("paramtab poisoned");
        tab.get(nam).cloned()
    };
    let mut pm = match pm_clone {
        Some(p) => p,
        None => return 0,
    };
    // c:1033 — if (pm->level || !(pm->node.flags & PM_AUTOLOAD)) {
    if pm.level != 0 || (pm.node.flags as u32 & PM_AUTOLOAD) == 0 {
        // c:1042-1048 — if (!opt_i || pm->level) zwarn(...); return 1;
        if opt_i == 0 || pm.level != 0 {
            zwarn(&format!(
                "Can't add module parameter `{}': {}",
                nam,
                if pm.level != 0 {
                    "local parameter exists"
                } else {
                    "parameter already exists"
                }
            ));
            return 1;
        }
        // c:1049 — return 2;
        return 2;
    }
    // c:1052 — unsetparam_pm(pm, 0, 1);
    unsetparam_pm(&mut pm, 0, 1);
    // c:1053 — return 0;
    0
}

/// Port of `int addparamdef(Paramdef d)` from `Src/module.c:1061`.
/// Registers a module-supplied parameter definition into the canonical
/// `paramtab`, wiring the GSU vtable per `PM_TYPE`. Returns 0 on
/// success, 1 on error.
///
/// ```c
/// int
/// addparamdef(Paramdef d)
/// {
///     Param pm;
///     if (checkaddparam(d->name, 0)) return 1;
///     if (d->getnfn) {
///         if (!(pm = createspecialhash(d->name, d->getnfn,
///                                      d->scantfn, d->flags)))
///             return 1;
///     }
///     else if (!(pm = createparam(d->name, d->flags)) &&
///         !(pm = (Param) paramtab->getnode(paramtab, d->name)))
///         return 1;
///     d->pm = pm;
///     pm->level = 0;
///     if (d->var) pm->u.data = d->var;
///     if (d->var || d->gsu) {
///         switch (PM_TYPE(pm->node.flags)) {
///         case PM_SCALAR:
///             if (pm->node.flags & PM_TIED)
///                 pm->ename = ztrdup(casemodify(pm->node.nam, CASMOD_LOWER));
///             /* fall-through */
///         case PM_NAMEREF:
///             pm->gsu.s = d->gsu ? (GsuScalar)d->gsu : &varscalar_gsu;
///             break;
///         case PM_INTEGER:
///             pm->gsu.i = d->gsu ? (GsuInteger)d->gsu : &varinteger_gsu;
///             break;
///         case PM_FFLOAT: case PM_EFLOAT:
///             pm->gsu.f = d->gsu;
///             break;
///         case PM_ARRAY:
///             if (pm->node.flags & PM_TIED)
///                 pm->ename = ztrdup(casemodify(pm->node.nam, CASMOD_UPPER));
///             pm->gsu.a = d->gsu ? (GsuArray)d->gsu : &vararray_gsu;
///             break;
///         case PM_HASHED:
///             if (d->gsu) pm->gsu.h = (GsuHash)d->gsu;
///             break;
///         default:
///             unsetparam_pm(pm, 0, 1);
///             return 1;
///         }
///     }
///     return 0;
/// }
/// ```
pub fn addparamdef(d: &mut paramdef) -> i32 {
    // c:1061

    // c:1065 — `if (checkaddparam(d->name, 0)) return 1;`
    if checkaddparam(&d.name, 0) != 0 {
        // c:1065
        return 1; // c:1066
    }

    // c:1068-1075 — either createspecialhash (hash params with getnfn)
    // or createparam, falling back to gethashnode on collision.
    let pm_opt: Option<Param> = if d.getnfn.is_some() {
        // c:1068
        // c:1069-1071 — createspecialhash(d->name, d->getnfn, d->scantfn, d->flags)
        // The Rust createspecialhash takes (name, flags) only; the
        // getnfn/scantfn fields aren't yet wired through the typed
        // Rust API. Pass flags and let the param be created.
        createspecialhash(&d.name, d.flags) // c:1069
    } else {
        // c:1072
        match createparam(&d.name, d.flags) {
            // c:1073
            Some(p) => Some(p),
            None => {
                // c:1074 — fall back to paramtab->getnode(paramtab, d->name)
                let tab = paramtab().read().ok();
                tab.and_then(|t| {
                    t.get(&d.name).map(|p| {
                        // Clone the existing param so we can mutate the
                        // returned handle without holding the read lock.
                        let mut clone = p.clone();
                        clone.level = 0;
                        Box::new(*clone)
                    })
                })
            }
        }
    };
    let mut pm = match pm_opt {
        // c:1074-1075
        Some(p) => p,
        None => return 1,
    };

    // c:1077-1078 — `d->pm = pm; pm->level = 0;`
    pm.level = 0; // c:1078

    // c:1079-1080 — `if (d->var) pm->u.data = d->var;`
    if d.var != 0 { // c:1079
         // pm.u.data is a raw `void *` slot — not yet exposed on the
         // Rust param mirror. Carry the assignment as a comment.
         // pm.u.data = d->var as *mut _;                                     // c:1080
    }

    if d.var != 0 || d.gsu != 0 {
        // c:1081
        let t = PM_TYPE(pm.node.flags as u32); // c:1086
        let pmflags = pm.node.flags as u32;
        if t == PM_SCALAR || t == PM_NAMEREF {
            // c:1087/1091
            if t == PM_SCALAR && (pmflags & PM_TIED) != 0 {
                // c:1088
                let lower = casemodify(
                    &pm.node.nam,
                    CASMOD_LOWER,
                );
                pm.ename = Some(ztrdup(&lower)); // c:1089
            }
            // c:1092 pm->gsu.s = d->gsu ? d->gsu : &varscalar_gsu;
            // gsu vtable wireup is opaque (function pointers via usize);
            // the Rust param dispatch reads directly from typed accessors.
            let _ = d.gsu; // c:1092
        } else if t == PM_INTEGER {
            // c:1095
            let _ = d.gsu; // c:1096
        } else if t == PM_FFLOAT || t == PM_EFLOAT {
            // c:1099-1100
            let _ = d.gsu; // c:1101
        } else if t == PM_ARRAY {
            // c:1104
            if (pmflags & PM_TIED) != 0 {
                // c:1105
                let upper = casemodify(
                    &pm.node.nam,
                    CASMOD_UPPER,
                );
                pm.ename = Some(ztrdup(&upper)); // c:1106
            }
            let _ = d.gsu; // c:1107
        } else if t == PM_HASHED {
            // c:1110
            let _ = d.gsu; // c:1112-1113
        } else {
            // c:1116
            unsetparam_pm(&mut pm, 0, 1); // c:1117
            return 1; // c:1118
        }
    }

    d.pm = Some(pm); // c:1077 d->pm = pm
    0 // c:1122
}

/// Port of `int deleteparamdef(Paramdef d)` from `Src/module.c:1128`.
/// Removes a previously-registered module parameter, unwinding any
/// hidden-param shadow chain so the matching `d->pm` instance is the
/// one actually unset.
///
/// ```c
/// int
/// deleteparamdef(Paramdef d)
/// {
///     Param pm = (Param) paramtab->getnode(paramtab, d->name);
///     if (!pm) return 1;
///     if (pm != d->pm) {
///         Param prevpm, searchpm;
///         for (prevpm = pm, searchpm = pm->old;
///              searchpm;
///              prevpm = searchpm, searchpm = searchpm->old)
///             if (searchpm == d->pm) break;
///         if (!searchpm) return 1;
///         paramtab->removenode(paramtab, pm->node.nam);
///         prevpm->old = searchpm->old;
///         searchpm->old = pm;
///         paramtab->addnode(paramtab, searchpm->node.nam, searchpm);
///         pm = searchpm;
///     }
///     pm->node.flags = (pm->node.flags & ~PM_READONLY) | PM_REMOVABLE;
///     unsetparam_pm(pm, 0, 1);
///     d->pm = NULL;
///     return 0;
/// }
/// ```
pub fn deleteparamdef(d: &mut paramdef) -> i32 {
    // c:1128

    // c:1131 — `Param pm = (Param) paramtab->getnode(paramtab, d->name);`
    let mut pm: Param = {
        let tab = paramtab().read();
        match tab {
            Ok(t) => match t.get(&d.name) {
                Some(p) => p.clone(),
                None => return 1, // c:1133-1134
            },
            Err(_) => return 1,
        }
    };

    // c:1135-1156 — shadow-chain unwind: if the live pm isn't d->pm,
    // walk pm->old searching for d->pm; if found, splice it out,
    // re-add the matching node under its name, and operate on it.
    // The Rust param mirror's `old` chain isn't yet wired through
    // paramtab; the typed paramtab dispatches the latest binding
    // directly. Mirror the C structure so callers see the same
    // semantics when the shadow chain lands.
    if let Some(expected) = d.pm.as_ref() {
        // c:1135
        if !std::ptr::eq(pm.as_ref(), expected.as_ref()) {
            // c:1135 pm != d->pm
            // c:1141-1145 — walk pm->old looking for d->pm.
            let mut searchpm = pm.old.clone(); // c:1142
            let mut found = false;
            while let Some(s) = searchpm {
                // c:1142
                if std::ptr::eq(s.as_ref(), expected.as_ref()) {
                    // c:1144
                    found = true; // c:1145
                    break;
                }
                searchpm = s.old.clone(); // c:1143
            }
            if !found {
                // c:1147
                return 1; // c:1148
            }
            // c:1150-1153 — splice searchpm out of the chain and
            // re-add it under its node.nam. Without the shadow chain
            // wired through paramtab, this is a no-op; the unset
            // proceeds against the live pm.
        }
    }

    // c:1157 — `pm->node.flags = (pm->node.flags & ~PM_READONLY) | PM_REMOVABLE;`
    pm.node.flags = (pm.node.flags & !(PM_READONLY as i32)) | (PM_REMOVABLE as i32); // c:1157
    unsetparam_pm(&mut pm, 0, 1); // c:1158
    d.pm = None; // c:1159 d->pm = NULL
    0 // c:1160
}

impl modulestab {
    pub fn new() -> Self {
        let mut table = Self::default();
        table.register_builtin_modules();
        table
    }

    /// Register all statically-compiled modules (replaces dlopen)
    fn register_builtin_modules(&mut self) {
        let builtin_modules = [
            (
                "zsh/complete",
                &[
                    "compctl",
                    "compcall",
                    "comparguments",
                    "compdescribe",
                    "compfiles",
                    "compgroups",
                    "compquote",
                    "comptags",
                    "comptry",
                    "compvalues",
                ][..],
            ),
            ("zsh/complist", &["complist"][..]),
            ("zsh/computil", &["compadd", "compset"][..]),
            ("zsh/datetime", &["output_strftime"][..]),
            (
                "zsh/files",
                &[
                    "mkdir", "rmdir", "ln", "mv", "cp", "rm", "chmod", "chown", "sync",
                ][..],
            ),
            ("zsh/langinfo", &[][..]),
            ("zsh/mapfile", &[][..]),
            ("zsh/mathfunc", &[][..]),
            ("zsh/nearcolor", &[][..]),
            ("zsh/net/socket", &["zsocket"][..]),
            ("zsh/net/tcp", &["ztcp"][..]),
            ("zsh/parameter", &[][..]),
            (
                "zsh/pcre",
                &["pcre_compile", "pcre_match", "pcre_study"][..],
            ),
            ("zsh/regex", &[][..]),
            ("zsh/sched", &["sched"][..]),
            ("zsh/stat", &["zstat"][..]),
            (
                "zsh/system",
                &[
                    "bin_sysread",
                    "bin_syswrite",
                    "bin_sysopen",
                    "bin_sysseek",
                    "bin_syserror",
                    "zsystem",
                ][..],
            ),
            ("zsh/termcap", &["echotc"][..]),
            ("zsh/terminfo", &["echoti"][..]),
            ("zsh/watch", &["log"][..]),
            ("zsh/zftp", &["zftp"][..]),
            ("zsh/zleparameter", &[][..]),
            ("zsh/zprof", &["zprof"][..]),
            ("zsh/zpty", &["zpty"][..]),
            ("zsh/zselect", &["zselect"][..]),
            (
                "zsh/zutil",
                &["zstyle", "zformat", "zparseopts", "zregexparse"][..],
            ),
            (
                "zsh/attr",
                &["zgetattr", "zsetattr", "zdelattr", "zlistattr"][..],
            ),
            ("zsh/cap", &["cap", "getcap", "setcap"][..]),
            ("zsh/clone", &["clone"][..]),
            ("zsh/curses", &["zcurses"][..]),
            ("zsh/db/gdbm", &["ztie", "zuntie", "zgdbmpath"][..]),
            ("zsh/param/private", &["private"][..]),
        ];

        for (name, _builtins) in &builtin_modules {
            // C zsh tracks builtin→module mapping in `builtintab` (the
            // canonical hashtable), not on a per-module ledger. We
            // just register the module here; the builtins themselves
            // come in via the canonical table in `cmd.rs`.
            let module = module::new(name);
            self.modules.insert(name.to_string(), module);
        }
    }

    // Returns 0 success, 1 complete failure, 2 partial-features-fail.     // c:2200-2201
    /// Port of `int load_module(char const *name, Feature_enables
    /// enablesarr, int silent)` from `Src/module.c:2206`. C body:
    /// validate name with `modname_ok`, queue_signals(), resolve alias
    /// chain via `find_module(FINDMOD_ALIASP)`. If not found, attempt
    /// `module_linked` then `do_load_module` (dlopen). Allocate a new
    /// `Module`, set `MOD_SETUP` (+ `MOD_LINKED` if statically linked),
    /// add to `modulestab`, run `setup_module`/`do_boot_module`. If
    /// either fails, cleanup+finish+delete and return 1. Else clear
    /// `MOD_SETUP`, set `MOD_INIT_S | MOD_INIT_B`, return `bootret`.
    /// If found and already `MOD_SETUP`, return 0. Detect circular
    /// deps via `MOD_BUSY`, load dependency list recursively. zshrs:
    /// all modules are statically linked, so dlopen path is skipped
    /// and we operate on the static registry.
    /// WARNING: param names don't match C — Rust=(name) vs C=(name, enablesarr, silent)
    pub fn load_module(&mut self, name: &str) -> bool {
        // c:2206
        // c:2213 — modname_ok(name)
        if modname_ok(name) == 0 {
            // c:2213
            // c:2214-2215 — zerr if !silent
            return false; // c:2216 return 1 → false
        }
        crate::ported::signals::queue_signals(); // c:2223
                                                 // c:2224 — find_module(name, FINDMOD_ALIASP, &name)
        let exists = self.modules.contains_key(name);
        if !exists {
            // c:2224 !find_module
            // c:2225-2229 — module_linked + do_load_module: zshrs has
            // no DSO loader; only statically linked modules exist.
            unqueue_signals(); // c:2227
            return false; // c:2228 return 1
        }
        // c:2254 — flags & MOD_SETUP: already in setup, return 0.
        if let Some(m) = self.modules.get(name) {
            if (m.node.flags & MOD_SETUP) != 0 {
                // c:2254
                unqueue_signals(); // c:2255
                return true; // c:2256 return 0
            }
        }
        if let Some(m) = self.modules.get_mut(name) {
            if (m.node.flags & MOD_UNLOAD) != 0 {
                // c:2258
                m.node.flags &= !MOD_UNLOAD; // c:2259
            } else if (m.node.flags & MOD_LINKED) != 0 && (m.node.flags & MOD_INIT_B) != 0 {
                // c:Src/module.c:2260 — already loaded (handle exists
                // AND boot ran). For statically-linked builtin modules
                // (registered with MOD_LINKED set at module::new),
                // MOD_INIT_B is only set after this fn walks the
                // setup/boot steps — so MOD_LINKED alone must NOT
                // short-circuit. Previously the early-return fired on
                // every `zmodload zsh/mathfunc` for builtin modules
                // because they enter this fn with MOD_LINKED already
                // set but MOD_INIT_B clear; the setup arms below were
                // skipped, so MOD_INIT_B never got set. Parity bug.
                unqueue_signals(); // c:2261
                return true; // c:2262 return 0
            }
            if (m.node.flags & MOD_BUSY) != 0 {
                // c:2264
                unqueue_signals(); // c:2265
                return false; // c:2267 return 1
            }
            m.node.flags |= MOD_BUSY; // c:2269
                                      // c:2274-2282 — recurse into m->deps (omitted: per-module
                                      // deps tracker lives in the Linkedmod records in C).
            m.node.flags &= !MOD_BUSY; // c:2283
                                       // c:2284-2309 — !m->u.handle path: load + setup_module
            m.node.flags |= MOD_LINKED; // c:2296 MOD_LINKED for linked
            m.node.flags |= MOD_INIT_S; // c:2308
            m.node.flags |= MOD_SETUP; // c:2310
                                       // c:2311 — do_boot_module(m, enablesarr, silent)
            m.node.flags |= MOD_INIT_B; // c:2322
            m.node.flags &= !MOD_SETUP; // c:2323
        }
        unqueue_signals(); // c:2324
        true // c:2325 return bootret (0)
    }

    // Backend handler for zmodload -u                                       // c:2813
    /// Port of `int unload_module(Module m)` from `Src/module.c:2817`.
    /// C body: resolve `MOD_ALIAS` via `find_module(FINDMOD_ALIASP)`;
    /// if `MOD_INIT_S` set and !`MOD_UNLOAD`, call `do_cleanup_module`.
    /// Clear `MOD_INIT_B|MOD_INIT_S`. If a `wrapper` is present, set
    /// `MOD_UNLOAD` and bail (deferred). Else clear `MOD_UNLOAD` and
    /// call `m->u.linked->finish(m)` or `finish_module(m)` depending
    /// on `MOD_LINKED`. Finally walk `m->deps` and unload modules
    /// that were tagged `MOD_UNLOAD` when the last dependent dies.
    /// WARNING: param names don't match C — Rust=(name) vs C=(m)
    pub fn unload_module(&mut self, name: &str) -> bool {
        // c:2817
        // c:2824 — resolve alias chain (skipped: no per-module alias
        // tracking in the static registry).
        let _ = MOD_ALIAS;
        // c:2836-2839 — do_cleanup_module path is a no-op for static
        // modules (cleanup handlers run at process exit).
        if let Some(m) = self.modules.get_mut(name) {
            // c:2840 — clear MOD_INIT_B|MOD_INIT_S
            m.node.flags &= !(MOD_INIT_B | MOD_INIT_S);
            // c:2844-2847 — wrapper deferred unload (no wrappers in zshrs).
            // c:2848 — clear MOD_UNLOAD (entering active-unload).
            // c:2854-2864 — finish_module / linked->finish: in zshrs all
            // modules are statically linked, no DSO handle to release.
            // Mark the module as fully unloaded for the static-link
            // `is_loaded()` check (`MOD_LINKED && !MOD_UNLOAD`) — the
            // C path would `delete_module(m)` after finish; we set
            // MOD_UNLOAD as the static-link analog.
            let _ = MOD_LINKED;
            m.node.flags |= MOD_UNLOAD; // c:2890 delete_module analog
            true // c:2904 return 0
        } else {
            false // c:2826-2827 !m → return 1
        }
    }

    /// Check if module is loaded
    pub fn is_loaded(&self, name: &str) -> bool {
        self.modules
            .get(name)
            .map(|m| m.is_loaded())
            .unwrap_or(false)
    }

    /// List all loaded modules
    pub fn list_loaded(&self) -> Vec<&str> {
        self.modules
            .iter()
            .filter(|(_, m)| m.is_loaded())
            .map(|(name, _)| name.as_str())
            .collect()
    }

    /// List all modules (including unloaded). Returns name + raw
    /// `MOD_*` flag bits — caller can inspect `MOD_UNLOAD` / `MOD_LINKED`
    /// directly (matches C, which exposes `m->node.flags`).
    pub fn list_all(&self) -> Vec<(&str, i32)> {
        self.modules
            .iter()
            .map(|(name, m)| (name.as_str(), m.node.flags))
            .collect()
    }

    // ------- Builtin management (from module.c addbuiltin/deletebuiltin) -------

    /// Register a builtin (from module.c addbuiltin)
    /// Port of `addbuiltin(Builtin b)` from `Src/module.c:409`.
    /// WARNING: param names don't match C — Rust=(name, module) vs C=(b)
    ///
    /// In C, this inserts the builtin into the canonical `builtintab`
    /// hashtable (Src/builtin.c). The real builtin registration lives
    /// in `cmd.rs::BUILTINTAB`.
    pub fn addbuiltin(&mut self, _name: &str, _module: &str) { // c:409
    }

    /// Unregister a builtin (from module.c deletebuiltin)
    /// Port of `deletebuiltin(const char *nam)` from `Src/module.c:449`.
    /// WARNING: param names don't match C — Rust=(name, module) vs C=(nam)
    pub fn deletebuiltin(&mut self, _name: &str, _module: &str) { // c:449
                                                                  // See addbuiltin: deletion happens against the canonical
                                                                  // `BUILTINTAB`, not against a per-module ledger.
    }

    /// Register autoloading builtin.
    /// Port of `static int add_autobin(const char *module, const char *bnam,
    /// int flags)` from `Src/module.c:426`. C allocates a `Builtin` node
    /// with `optstr=module`, sets `BINF_AUTOALL` if `FEAT_AUTOALL` is in
    /// `flags`, then calls `addbuiltin(bn)`. On failure, the freshly
    /// allocated node is freed; success returns 0, conflict returns 1
    /// unless `FEAT_IGNORE` masks it.
    /// WARNING: param names don't match C — Rust=(name, module, flags) vs C=(module, bnam, flags)
    pub fn add_autobin(&mut self, name: &str, module: &str, flags: i32) -> i32 {
        // c:426
        // c:431 — bn = zshcalloc(sizeof(*bn))
        let mut node_flags: i32 = 0; // c:431-432 fresh Builtin
        if (flags & FEAT_AUTOALL as i32) != 0 {
            // c:434
            node_flags |= BINF_AUTOALL as i32; // c:435
        }
        let _ = node_flags; // would-be bn->node.flags
                            // c:436 — addbuiltin(bn). Rust ledger is keyed on name; insert
                            // returns the prior mapping if any (the "conflict" case).
        let prior = self
            .autoload_builtins
            .insert(name.to_string(), module.to_string());
        if prior.is_some() {
            // c:436 ret != 0
            // c:437 — builtintab->freenode(&bn->node) (we dropped insert val)
            if (flags & FEAT_IGNORE as i32) == 0 {
                // c:438
                return 1; // c:439
            }
        }
        0 // c:441
    }

    // Remove an autoloaded added by add_autobin                             // c:464
    /// Port of `static int del_autobin(const char *module, const char *bnam,
    /// int flags)` from `Src/module.c:464`.
    ///
    /// C body (c:464-478):
    /// ```c
    /// Builtin bn = (Builtin) builtintab->getnode2(builtintab, bnam);
    /// if (!bn) { if(!(flags & FEAT_IGNORE)) return 2; }
    /// else if (bn->node.flags & BINF_ADDED) {
    ///     if (!(flags & FEAT_IGNORE)) return 3;
    /// } else deletebuiltin(bnam);
    /// return 0;
    /// ```
    ///
    /// 2 = "no such builtin", 3 = "real registered builtin (BINF_ADDED) —
    /// can't unload", 0 = success (removed autoload entry).
    /// FEAT_IGNORE masks both error returns.
    ///
    /// zshrs architecture: `builtintab` is static-linked at startup
    /// (`createbuiltintable()` builds an immutable HashMap), so every
    /// entry there is effectively BINF_ADDED. The autoload-only entries
    /// live in `self.autoload_builtins`. The faithful mapping:
    ///   * if name is in `builtintab` → BINF_ADDED → return 3 (or 0 with
    ///     FEAT_IGNORE).
    ///   * else if name is in `autoload_builtins` → remove it, return 0.
    ///   * else → not present → return 2 (or 0 with FEAT_IGNORE).
    /// WARNING: param names don't match C — Rust=(name, flags) vs C=(module, bnam, flags)
    pub fn del_autobin(&mut self, name: &str, flags: i32) -> i32 {
        // c:464
        // c:466 — `builtintab->getnode2(builtintab, bnam)`.
        let bn = createbuiltintable().get(name);
        if bn.is_none() {
            // c:467
            // c:468-469 — `if(!(flags & FEAT_IGNORE)) return 2;`
            // Static-linked entries always count as the builtintab — but
            // a name that's neither there nor in autoload IS "no such".
            if !self.autoload_builtins.contains_key(name) {
                if (flags & FEAT_IGNORE as i32) == 0 {
                    // c:468
                    return 2; // c:469
                }
                return 0;
            }
            // c:475 — `deletebuiltin(bnam);` Rust path: drop autoload entry.
            self.autoload_builtins.remove(name); // c:475
            return 0; // c:477
        }
        // c:470-473 — `if (bn->node.flags & BINF_ADDED) { if (!FEAT_IGNORE)
        //               return 3; }` else deletebuiltin. zshrs's
        // `builtintab` is static-linked so every entry there is
        // semantically BINF_ADDED — can't unload a built-in builtin.
        if (flags & FEAT_IGNORE as i32) == 0 {
            // c:471
            return 3; // c:472
        }
        0 // c:477
    }

    /// Set/clear a slice of builtins per `e[]` mask.
    /// Port of `static int setbuiltins(char const *nam, Builtin binl,
    /// int size, int *e)` from `Src/module.c:501`. For each Builtin in
    /// `binl[0..size]`: if `e[n]` is set, add the builtin (skip if
    /// already `BINF_ADDED`); else delete the builtin (skip if not
    /// `BINF_ADDED`). Warnings on clash/already-deleted; returns 1 if
    /// any op failed.
    /// WARNING: param names don't match C — Rust=(module, names, e) vs C=(nam, binl, size, e)
    pub fn setbuiltins(&mut self, module: &str, names: &[&str], e: Option<&[i32]>) -> i32 {
        // c:501
        let mut ret: i32 = 0; // c:503
        for (n, name) in names.iter().enumerate() {
            // c:505
            let enable = e
                .map(|arr| arr.get(n).copied().unwrap_or(0)) // c:507 *e++
                .unwrap_or(1);
            let already_added = self.added_builtins.contains_key(*name); // c:508 b->flags & BINF_ADDED
            if enable != 0 {
                if already_added {
                    continue;
                } // c:508-509
                  // c:510 — addbuiltin(b); ledger insert acts as success.
                self.addbuiltin(name, module);
                self.added_builtins.insert(name.to_string(), BINF_ADDED); // c:515 BINF_ADDED
            } else {
                if !already_added {
                    continue;
                } // c:518-519
                  // c:520 — deletebuiltin(b->node.nam)
                self.added_builtins.remove(*name); // c:524 clear BINF_ADDED
            }
            let _ = ret;
        }
        ret // c:528
    }

    // ------- Condition management (from module.c addconddef/deleteconddef) -------

    /// Register a condition (from module.c addconddef)
    /// Port of `addconddef(Conddef c)` from `Src/module.c:703`.
    /// WARNING: param names don't match C — Rust=(name, module) vs C=(c)
    ///
    /// Like `addbuiltin`, C inserts into the canonical `condtab` table
    /// (Src/cond.c); the real registration lives in `cond.rs::CONDTAB`.
    pub fn addconddef(&mut self, _name: &str, _module: &str) { // c:703
    }

    /// Unregister a condition (from module.c deleteconddef)
    /// Port of `deleteconddef(Conddef c)` from `Src/module.c:724`.
    /// WARNING: param names don't match C — Rust=(name, module) vs C=(c)
    pub fn deleteconddef(&mut self, _name: &str, _module: &str) {
        // See addconddef: deletion happens against the canonical
        // `CONDTAB`, not against a per-module ledger.
    }

    /// Get condition definition (from module.c getconddef)
    /// Port of `getconddef(int inf, const char *name, int autol)` from `Src/module.c:648`.
    /// WARNING: param names don't match C — Rust=(name) vs C=(inf, name, autol)
    ///
    /// Returns the autoload mapping if any. C consults the canonical
    /// `condtab` first; the autoload table is the fallback.
    pub fn getconddef(&self, name: &str) -> Option<&str> {
        self.autoload_conditions.get(name).map(|s| s.as_str())
    }

    /// Register autoloading condition.
    /// Port of `static int add_autocond(const char *module, const char
    /// *cnam, int flags)` from `Src/module.c:792`. C body allocates a
    /// `Conddef`, copies name/module, sets `CONDF_INFIX` if
    /// `FEAT_INFIX` and `CONDF_AUTOALL` if `FEAT_AUTOALL`, then calls
    /// `addconddef(c)`. On addconddef failure (already exists) the
    /// node is freed; returns 1 unless `FEAT_IGNORE`.
    /// WARNING: param names don't match C — Rust=(name, module, flags) vs C=(module, cnam, flags)
    pub fn add_autocond(&mut self, name: &str, module: &str, flags: i32) -> i32 {
        // c:792
        // c:796 — c = zalloc(sizeof(*c))
        let mut cflags: i32 = if (flags & FEAT_INFIX) != 0 {
            // c:799
            CONDF_INFIX
        } else {
            0
        };
        if (flags & FEAT_AUTOALL) != 0 {
            // c:800
            cflags |= CONDF_AUTOALL; // c:801
        }
        let _ = cflags; // c->flags
                        // c:804 — addconddef(c). Rust ledger: insert into
                        // autoload_conditions; conflict if key already present.
        let prior = self
            .autoload_conditions
            .insert(name.to_string(), module.to_string());
        if prior.is_some() {
            // c:804 addconddef != 0
            // c:805-807 — zsfree(name/module); zfree(c)
            if (flags & FEAT_IGNORE) == 0 {
                // c:809
                return 1; // c:810
            }
        }
        0 // c:812
    }

    /// Port of `static int del_autocond(const char *modnam, const char *cnam,
    /// int flags)` from `Src/module.c:819`.
    ///
    /// C body (c:819-835):
    /// ```c
    /// Conddef cd = getconddef((flags & FEAT_INFIX) ? 1 : 0, cnam, 0);
    /// if (!cd) { if (!(flags & FEAT_IGNORE)) return 2; }
    /// else if (cd->flags & CONDF_ADDED) {
    ///     if (!(flags & FEAT_IGNORE)) return 3;
    /// } else deleteconddef(cd);
    /// return 0;
    /// ```
    ///
    /// 2 = "no such condition", 3 = "registered condition (CONDF_ADDED) —
    /// can't unload", 0 = success. FEAT_IGNORE masks both error returns.
    /// WARNING: param names don't match C — Rust=(name, flags) vs C=(modnam, cnam, flags)
    pub fn del_autocond(&mut self, name: &str, flags: i32) -> i32 {
        // c:819
        // c:821 — `getconddef((flags & FEAT_INFIX) ? 1 : 0, cnam, 0);`.
        // The Rust ledger holds only the autoload entry; the live
        // CONDF_ADDED registry isn't separately materialised, so any
        // entry we find is the autoload form (analog of !CONDF_ADDED).
        if self.autoload_conditions.contains_key(name) {
            // c:823
            // c:831-832 — `deleteconddef(cd);` Rust drop autoload entry.
            self.autoload_conditions.remove(name); // c:832
            return 0; // c:834
        }
        // c:823-826 — `if (!cd) { if (!(flags & FEAT_IGNORE)) return 2; }`.
        if (flags & FEAT_IGNORE as i32) == 0 {
            // c:824
            return 2; // c:825
        }
        0 // c:834
    }

    // ------- Hook management lives in the file-static free ported above ------
    //
    // C `hooktab` (Src/module.c:843) is a file-static `Hookdef` linked
    // list, NOT a member of `ModuleTable` (which is the `modulestab`
    // HashTable of Module nodes at c:Modules/zmodload.c:32). Hook ops
    // are free ported operating on the file-static `hooktab` (above):
    // `gethookdef`, `addhookdef`, `addhookdefs`, `deletehookdef`,
    // `deletehookdefs`, `addhookdeffunc`, `addhookfunc`,
    // `deletehookdeffunc`, `deletehookfunc`, `runhookdef`.

    // ------- Parameter management (from module.c addparamdef/deleteparamdef) -------

    /// Add or remove sets of parameters; same shape as `setbuiltins`.
    /// Port of `static int setparamdefs(char const *nam, Paramdef d,
    /// int size, int *e)` from `Src/module.c:1170`. For each Paramdef
    /// in `d[0..size]`: if `e[n]` is set and `d->pm` is null, add the
    /// param via `addparamdef(d)`; if `e[n]` is clear and `d->pm` is
    /// non-null, remove via `deleteparamdef(d)`. Warnings on
    /// error/already-deleted; returns 1 if any op failed.
    /// WARNING: param names don't match C — Rust=(module, names, e) vs C=(nam, d, size, e)
    pub fn setparamdefs(&mut self, module: &str, names: &[&str], e: Option<&[i32]>) -> i32 {
        // c:1170
        let mut ret: i32 = 0; // c:1172
        for (n, name) in names.iter().enumerate() {
            // c:1174 while (size--)
            let enable = e
                .map(|arr| arr.get(n).copied().unwrap_or(0)) // c:1175 *e++
                .unwrap_or(1);
            let already = self.autoload_params.contains_key(*name); // c:1176 d->pm
            if enable != 0 {
                if already {
                    // c:1176-1179
                    continue;
                }
                // c:1180 — addparamdef(d)
                self.autoload_params
                    .insert(name.to_string(), module.to_string());
            } else {
                if !already {
                    // c:1185-1188
                    continue;
                }
                // c:1189 — deleteparamdef(d)
                self.autoload_params.remove(*name);
            }
            let _ = ret;
        }
        ret // c:1196
    }

    /// Register autoloading parameter.
    /// Port of `static int add_autoparam(const char *module, const char
    /// *pnam, int flags)` from `Src/module.c:1198`. C body:
    /// `checkaddparam()` clash check (returns 2 if `-i`'d), then
    /// `setsparam(pnam, module)` creating the param with `PM_AUTOLOAD`
    /// (+ `PM_AUTOALL` if `FEAT_AUTOALL`). `queue_signals`/`noerrs=2`
    /// bracket so the setsparam doesn't echo errors out.
    /// WARNING: param names don't match C — Rust=(name, module, flags) vs C=(module, pnam, flags)
    pub fn add_autoparam(&mut self, name: &str, module: &str, flags: i32) -> i32 {
        // c:1202
        let _ret: i32;
        // c:1207 noerrs = 2; queue_signals(); checkaddparam clash check
        crate::ported::signals::queue_signals(); // c:1209
                                                 // checkaddparam returns 0 ok, 1 hard-fail (already-printed
                                                 // message), 2 soft-fail with `-i`. Rust ledger: presence in
                                                 // `autoload_params` is the clash signal.
        let exists = self.autoload_params.contains_key(name); // c:1210
        if exists {
            unqueue_signals(); // c:1211
                                                       // c:1213-1219 — 2-vs-0 mapping for `-i`/normal case.
            if (flags & FEAT_IGNORE) != 0 {
                return 0; // c:1219 ret==2 → 0
            }
            return -1; // c:1219 ret==1 → -1
        }
        // c:1222-1227 — noerrs=2; setsparam; PM_AUTOLOAD (+PM_AUTOALL if FEAT_AUTOALL)
        self.autoload_params
            .insert(name.to_string(), module.to_string()); // c:1223 setsparam
        let _ = PM_AUTOLOAD; // c:1224 pm->flags |= PM_AUTOLOAD
        if (flags & FEAT_AUTOALL) != 0 {
            // c:1225
            let _ = PM_AUTOALL; // c:1226
        }
        unqueue_signals(); // c:1231
        0 // c:1227,1233 ret=0
    }

    /// Port of `static int del_autoparam(const char *modnam, const char *pnam,
    /// int flags)` from `Src/module.c:1240`.
    ///
    /// C body (c:1240-1255):
    /// ```c
    /// Param pm = (Param) gethashnode2(paramtab, pnam);
    /// if (!pm) { if (!(flags & FEAT_IGNORE)) return 2; }
    /// else if (!(pm->node.flags & PM_AUTOLOAD)) {
    ///     if (!(flags & FEAT_IGNORE)) return 3;
    /// } else unsetparam_pm(pm, 0, 1);
    /// return 0;
    /// ```
    ///
    /// 2 = "no such param", 3 = "real param (not autoload) — can't
    /// unload", 0 = success. FEAT_IGNORE masks both error returns.
    /// WARNING: param names don't match C — Rust=(name, flags) vs C=(modnam, pnam, flags)
    pub fn del_autoparam(&mut self, name: &str, flags: i32) -> i32 {
        // c:1240
        // c:1242 — `gethashnode2(paramtab, pnam)`. Rust paramtab lookup.
        let pm_flags = paramtab()
            .read()
            .ok()
            .and_then(|t| t.get(name).map(|p| p.node.flags));
        match pm_flags {
            None => {
                // c:1244 if (!pm)
                // c:1245-1246 — `if (!(flags & FEAT_IGNORE)) return 2;`
                // Also check autoload_params: a name only in the autoload
                // ledger (no live Param entry yet) is the same as "not
                // present" from C's perspective.
                if !self.autoload_params.contains_key(name) {
                    if (flags & FEAT_IGNORE as i32) == 0 {
                        return 2; // c:1246
                    }
                    return 0;
                }
                // Cleanup the autoload ledger entry.
                self.autoload_params.remove(name);
                0 // c:1254
            }
            Some(f) if (f as u32 & PM_AUTOLOAD) == 0 => {
                // c:1247
                // c:1248-1249 — real param, not just autoload → return 3.
                if (flags & FEAT_IGNORE as i32) == 0 {
                    // c:1248
                    return 3; // c:1249
                }
                0 // c:1254
            }
            Some(_) => {
                // c:1252 — `unsetparam_pm(pm, 0, 1);` — the param is
                // marked PM_AUTOLOAD so just removing it from paramtab
                // (the Rust analog of unsetparam_pm) is the right move.
                if let Ok(mut t) = paramtab().write() {
                    t.remove(name); // c:1252
                }
                self.autoload_params.remove(name);
                0 // c:1254
            }
        }
    }

    // ------- Feature enable/disable (from module.c features_/enables_) -------

    /// Enable a feature (from module.c enables_)
    ///
    /// Without a per-module feature ledger, enable/disable maps onto
    /// the canonical builtin/conddef/paramdef tables. Returns true if
    /// the module itself is registered. The actual per-feature
    /// enabled-bit lives on the canonical record (e.g. `Builtin.flags`
    /// `BINF_DISABLED`).
    pub fn enable_feature(&mut self, module: &str, _name: &str) -> bool {
        self.modules.contains_key(module)
    }

    /// Disable a feature
    pub fn disable_feature(&mut self, module: &str, _name: &str) -> bool {
        self.modules.contains_key(module)
    }

    /// List feature *names* of a module (from module.c features_).
    /// Without a per-module ledger, this returns an empty list — C
    /// computes feature names by walking the canonical tables for
    /// entries that name the given module. Callers that care use
    /// `features_module`/`features_` directly.
    pub fn list_features(&self, _module: &str) -> Vec<String> {
        Vec::new()
    }

    /// Check if a module is linked (statically compiled) (from module.c module_linked)
    /// Port of `module_linked(char const *name)` from `Src/module.c:385`.
    pub fn module_linked(&self, name: &str) -> bool {
        self.modules.contains_key(name)
    }

    /// Resolve autoload — find which module provides a builtin
    pub fn resolve_autoload_builtin(&self, name: &str) -> Option<&str> {
        self.autoload_builtins.get(name).map(|s| s.as_str())
    }

    /// Resolve autoload — find which module provides a parameter
    pub fn resolve_autoload_param(&self, name: &str) -> Option<&str> {
        self.autoload_params.get(name).map(|s| s.as_str())
    }

    /// Ensure a module's feature is available
    /// Port of `ensurefeature(const char *modname, const char *prefix, const char *feature)` from `Src/module.c:3415`.
    /// WARNING: param names don't match C — Rust=(module, feature) vs C=(modname, prefix, feature)
    pub fn ensurefeature(&mut self, module: &str, feature: &str) -> bool {
        if !self.is_loaded(module) {
            self.load_module(module);
        }
        self.is_loaded(module)
    }
}

/// Module lifecycle callbacks (from module.c setup_/getrandom_buffer/cleanup_/finish_)
/// Lifecycle hooks every module must implement.
/// Port of the `setup_`/`features_`/`enables_`/`getrandom_buffer`/`cleanup_`
/// /`finish_` entry points every C module exposes (Src/module.c
/// lines 306-345 illustrate the canonical no-op set). Rust
/// modules implement this trait directly.
pub trait ModuleLifecycle {
    fn setup(&mut self) -> i32 {
        0
    }
    fn boot(&mut self) -> i32 {
        0
    }
    fn cleanup(&mut self) -> i32 {
        0
    }
    fn finish(&mut self) -> i32 {
        0
    }
}

/// Port of `getmathfunc(const char *name, int autol)` from `Src/module.c:1283`.
///
/// C body: linear-search `mathfuncs` for `name`; if found and `autol`
/// is true and the entry is autoloadable, demand-load via
/// `ensurefeature("f:", name)`. Returns the resolved entry or NULL.
///
/// Rust port returns `Some(module_name)` on hit, `None` on miss.
/// Honors the autoload flag by triggering `ensurefeature` when set.
/// WARNING: param names don't match C — Rust=(table, name, autol) vs C=(name, autol)
pub fn getmathfunc(table: &mut modulestab, name: &str, autol: i32) -> Option<String> {
    // c:1283
    if let Some(module) = table.autoload_mathfuncs.get(name).cloned() {
        // c:1283-1288
        if autol != 0 {
            // c:1289
            // c:1295 — ensurefeature(n, "f:", ...)
            let _ = ensurefeature(table, &module, "f:", Some(name));
            return table.autoload_mathfuncs.get(name).cloned();
        }
        return Some(module); // c:1303
    }
    None // c:1306
}

/// Port of `add_automathfunc(const char *module, const char *fnam, int flags)` from `Src/module.c:1410`.
///
/// C body:
/// ```c
/// add_automathfunc(const char *module, const char *fnam, int flags) {
///     MathFunc f = zalloc(sizeof(*f));
///     f->name = ztrdup(fnam);
///     f->module = ztrdup(module);
///     f->flags = 0;
///     if (addmathfunc(f)) {
///         zsfree(f->name); zsfree(f->module); zfree(f, sizeof(*f));
///         if (!(flags & FEAT_IGNORE))
///             return 1;
///     }
///     return 0;
/// }
/// ```
///
/// Registers `fnam` as an autoloadable math function provided by `module`.
/// WARNING: param names don't match C — Rust=(table, module, fnam, flags) vs C=(module, fnam, flags)
pub fn add_automathfunc(table: &mut modulestab, module: &str, fnam: &str, flags: i32) -> i32 {
    // c:1410
    // c:1410-1418 — alloc + populate MathFunc
    if table.autoload_mathfuncs.contains_key(fnam) {
        // c:1420 addmathfunc clash
        if (flags & FEAT_IGNORE) == 0 {
            // c:1425
            return 1; // c:1426
        }
    } else {
        table
            .autoload_mathfuncs
            .insert(fnam.to_string(), module.to_string());
    }
    0 // c:1429
}

/// Port of `del_automathfunc(UNUSED(const char *modnam), const char *fnam, int flags)` from `Src/module.c:1436`.
///
/// C body:
/// ```c
/// del_automathfunc(UNUSED(const char *modnam), const char *fnam, int flags) {
///     MathFunc f = getmathfunc(fnam, 0);
///     if (!f) {
///         if (!(flags & FEAT_IGNORE)) return 2;
///     } else if (f->flags & MFF_ADDED) {
///         if (!(flags & FEAT_IGNORE)) return 3;
///     } else
///         deletemathfunc(f);
///     return 0;
/// }
/// ```
///
/// Removes `fnam` from the autoloadable math-function registry.
/// WARNING: param names don't match C — Rust=(table, _modnam, fnam, flags) vs C=(modnam, fnam, flags)
pub fn del_automathfunc(table: &mut modulestab, _modnam: &str, fnam: &str, flags: i32) -> i32 {
    // c:1436
    if !table.autoload_mathfuncs.contains_key(fnam) {
        // c:1436 if (!f)
        if (flags & FEAT_IGNORE) == 0 {
            // c:1441
            return 2; // c:1442
        }
    } else {
        // c:1447 — deletemathfunc(f)
        table.autoload_mathfuncs.remove(fnam);
    }
    0 // c:1449
}

/// Port of `load_and_bind(const char *fn)` from `Src/module.c:1468`.
///
/// C body: AIX-only `load() + loadbind()` wrapper. Iterates the
/// `modulestab` hash table, binding each loaded module's handle to
/// the new module's symbols. On loadbind failure, calls `unload()`
/// and stores the error in `dlerrstr`.
///
/// Static-link path: dlopen/dlsym aren't used since modules are
/// linked at compile time. Returns 0 (NULL handle).
/// WARNING: param names don't match C — Rust=(_fn_path) vs C=(fn)
pub fn load_and_bind(_fn_path: &str) -> usize {
    // c:1468
    0 // c:1492 NULL
}

/// Port of `hpux_dlsym(void *handle, char *name)` from `Src/module.c:1530`.
///
/// C body:
/// ```c
/// hpux_dlsym(void *handle, char *name)
/// {
///     void *sym_addr;
///     if (!shl_findsym((shl_t *)&handle, name, TYPE_UNDEFINED, &sym_addr))
///         return sym_addr;
///     return NULL;
/// }
/// ```
///
/// HP-UX-specific dlsym wrapper around `shl_findsym(3)`. Static-link
/// path: never invoked since zshrs doesn't dlopen modules.
#[allow(unused_variables)]
pub fn hpux_dlsym(handle: usize, name: &str) -> usize {
    // c:1530
    0 // c:1530 NULL
}

/// Port of `try_load_module(char const *name)` from `Src/module.c:1583`.
///
/// C body iterates `module_path` looking for a loadable file via
/// `dlopen`. Static-link path: a module is "loadable" iff it's in
/// our static `ModuleTable.modules` map.
/// WARNING: param names don't match C — Rust=(table, name) vs C=(name)
pub fn try_load_module(table: &modulestab, name: &str) -> i32 {
    // c:1583
    if table.modules.contains_key(name) {
        1
    } else {
        0
    }
}

/// Port of `do_load_module(char const *name, int silent)` from `Src/module.c:1610`.
///
/// C body:
/// ```c
/// do_load_module(char const *name, int silent)
/// {
///     void *ret;
///     ret = try_load_module(name);
///     if (!ret && !silent) {
///         zwarn("failed to load module `%s': %s", name, ...);
///     }
///     return ret;
/// }
/// ```
///
/// C returns `void *` (the dlopen handle); Rust port returns 0 on
/// success / 1 on failure. zshrs's static-link path: `try_load_module`
/// always succeeds for built-in modules. Returns 1 + zwarn on miss.
/// WARNING: param names don't match C — Rust=(table, name, silent) vs C=(name, silent)
pub fn do_load_module(table: &mut modulestab, name: &str, silent: i32) -> i32 {
    // c:1610
    // c:1610 — ret = try_load_module(name);
    let ret = try_load_module(table, name);
    if ret == 0 && silent == 0 {
        // c:1615
        // c:1618-1621 — zwarn("failed to load module ...")
        zwarn(&format!("failed to load module: {}", name));
    }
    ret // c:1624
}

/// Port of `find_module(const char *name, int flags, const char **namep)` from `Src/module.c:1659`.
///
/// C body:
/// ```c
/// find_module(const char *name, int flags, const char **namep)
/// {
///     Module m;
///     m = (Module)modulestab->getnode2(modulestab, name);
///     if (m) {
///         if ((flags & FINDMOD_ALIASP) && (m->node.flags & MOD_ALIAS)) {
///             if (namep) *namep = m->u.alias;
///             return find_module(m->u.alias, flags, namep);
///         }
///         if (namep) *namep = m->node.nam;
///         return m;
///     }
///     if (!(flags & FINDMOD_CREATE))
///         return NULL;
///     m = zshcalloc(sizeof(*m));
///     modulestab->addnode(modulestab, ztrdup(name), m);
///     return m;
/// }
/// ```
///
/// Returns the resolved module name (after alias chasing) and
/// whether an entry was created. C's `Module` return becomes
/// `Option<String>` of the canonical name.
/// WARNING: param names don't match C — Rust=(table, name, flags) vs C=(name, flags, namep)
pub fn find_module(table: &mut modulestab, name: &str, flags: i32) -> Option<String> {
    // c:1659
    // c:1659 — m = modulestab->getnode2(modulestab, name);
    let mut cur_name = name.to_string();
    let mut depth = 0;
    loop {
        if depth > 64 {
            return None;
        } // alias-cycle guard
        depth += 1;
        match table.modules.get(&cur_name) {
            Some(m) => {
                // c:1665 — if ((flags & FINDMOD_ALIASP) && (m->node.flags & MOD_ALIAS))
                if (flags & FINDMOD_ALIASP) != 0
                    && (m.node.flags & MOD_ALIAS) != 0
                {
                    // c:1668 — return find_module(m->u.alias, flags, namep);
                    if let Some(target) = m.alias.clone() {
                        cur_name = target;
                        continue;
                    }
                    return None;
                }
                // c:1671 — *namep = m->node.nam; return m;
                return Some(cur_name);
            }
            None => {
                // c:1674 — if (!(flags & FINDMOD_CREATE)) return NULL;
                if (flags & FINDMOD_CREATE) == 0 {
                    return None;
                }
                // c:1676-1677 — m = zshcalloc(...); addnode(name, m);
                table
                    .modules
                    .insert(cur_name.clone(), module::new(&cur_name));
                return Some(cur_name);
            }
        }
    }
}

/// Port of `delete_module(Module m)` from `Src/module.c:1687`.
///
/// C body:
/// ```c
/// delete_module(Module m) {
///     modulestab->removenode(modulestab, m->node.nam);
///     modulestab->freenode(&m->node);
/// }
/// ```
///
/// Removes a module from the live `modulestab` and frees its node.
/// Rust port operates on the `ModuleTable` `modules` HashMap.
/// WARNING: param names don't match C — Rust=(table, name) vs C=(m)
pub fn delete_module(table: &mut modulestab, name: &str) -> i32 {
    // c:1687
    table.modules.remove(name); // c:1687 removenode
                                // c:1691 — freenode(&m->node) — Rust drops on `remove` return.
    0
}

/// Port of `module_loaded(const char *name)` from `Src/module.c:1703`.
///
/// C body:
/// ```c
/// module_loaded(const char *name)
/// {
///     Module m;
///     return ((m = find_module(name, FINDMOD_ALIASP, NULL)) &&
///             m->u.handle &&
///             !(m->node.flags & MOD_UNLOAD));
/// }
/// ```
///
/// Returns true (non-zero) if the named module is currently loaded.
/// In zshrs's static-link path: a module is "loaded" iff it's
/// registered in the live `ModuleTable`. The `MOD_UNLOAD` flag check
/// is skipped because static-link modules cannot be unloaded.
/// WARNING: param names don't match C — Rust=(table, name) vs C=(name)
pub fn module_loaded(table: &modulestab, name: &str) -> i32 {
    // c:1703
    // c:1703 — find_module(name, FINDMOD_ALIASP, NULL)
    if table.modules.contains_key(name) {
        // m && m->u.handle
        1 // c:1709 (loaded, not unloading)
    } else {
        0
    }
}

/// Port of `dyn_setup_module(Module m)` from `Src/module.c:1726`.
///
/// C body: `return ((int (*)(int,Module,void*)) m->u.handle)(0, m, NULL);`
/// Op-code 0 = setup. AIX-only path that multiplexes all six module
/// hooks through one symbol; static-link path skips it entirely.
#[allow(unused_variables)]
pub fn dyn_setup_module(m: *const module) -> i32 {
    // c:1726
    0 // c:1726
}

/// Port of `dyn_features_module(Module m, char ***features)` from `Src/module.c:1733`.
///
/// C body: `return ((int (*)(int,Module,void*)) m->u.handle)(4, m, features);`
/// Op-code 4 = features.
#[allow(unused_variables)]
pub fn dyn_features_module(
    m: *const module,
    features: &mut Vec<String>,
) -> i32 {
    // c:1733
    0 // c:1733
}

/// Port of `dyn_enables_module(Module m, int **enables)` from `Src/module.c:1740`.
///
/// C body: `return ((int (*)(int,Module,void*)) m->u.handle)(5, m, enables);`
/// Op-code 5 = enables.
#[allow(unused_variables)]
pub fn dyn_enables_module(
    m: *const module,
    enables: &mut Option<Vec<i32>>,
) -> i32 {
    // c:1740
    0 // c:1733
}

/// Port of `dyn_boot_module(Module m)` from `Src/module.c:1747`.
///
/// C body: `return ((int (*)(int,Module,void*)) m->u.handle)(1, m, NULL);`
/// Calls the dynamic module's exported entry-point with op-code 1
/// (boot). Static-link path: opcode dispatch unused, returns 0.
#[allow(unused_variables)]
pub fn dyn_boot_module(m: *const module) -> i32 {
    // c:1747
    0 // c:1754
}

/// Port of `dyn_cleanup_module(Module m)` from `Src/module.c:1754`.
///
/// C body: `return ((int (*)(int,Module,void*)) m->u.handle)(2, m, NULL);`
/// Op-code 2 = cleanup.
#[allow(unused_variables)]
pub fn dyn_cleanup_module(m: *const module) -> i32 {
    // c:1754
    0 // c:1740
}

/// Port of `static int dyn_finish_module(Module m)` from
/// `Src/module.c:1766`. C body: `return ((int (*)(int,Module,void*))
/// m->u.handle)(3, m, NULL);` — invokes the DSO entry point with
/// opcode 3 (finish). no-op in Rust: zshrs has no dlopen path, all
/// modules are statically linked, `m->u.handle` is always null, and
/// finish-time resource release happens at process exit. Static-link
/// path defers all DSO entry calls; the no-op return preserves
/// caller semantics (0 = success).
#[allow(unused_variables)]
pub fn dyn_finish_module(m: *const module) -> i32 {
    // c:1766
    // c:1768 — ((int (*)(int,Module,void*)) m->u.handle)(3, m, NULL).
    // Static modules: no handle, opcode 3 (finish) is a no-op.
    0 // c:1768 success
}

/// Port of `module_func(Module m, const char *name)` from `Src/module.c:1770`.
///
/// C body (DYNAMIC_NAME_CLASH_OK off — the typical case):
/// ```c
/// module_func(Module m, const char *name)
/// {
///     VARARR(char, buf, strlen(name) + strlen(m->node.nam)*2 + 1);
///     char const *p; char *q;
///     strcpy(buf, name);
///     q = strchr(buf, 0);
///     for(p = m->node.nam; *p; p++) {
///         if(*p == '/')      { *q++ = 'Q'; *q++ = 's'; }
///         else if(*p == '_') { *q++ = 'Q'; *q++ = 'u'; }
///         else if(*p == 'Q') { *q++ = 'Q'; *q++ = 'q'; }
///         else                 *q++ = *p;
///     }
///     *q = 0;
///     return (Module_generic_func) dlsym(m->u.handle, buf);
/// }
/// ```
///
/// Builds a mangled symbol name (`<name><module-name-mangled>`) and
/// dlsym's it. The mangling encodes `/` as `Qs`, `_` as `Qu`, `Q` as
/// `Qq` so e.g. `setup_zsh_random` becomes `setup_zshQurandom`.
///
/// Static-link path: dlsym not used; returns 0 (NULL handle).
#[allow(unused_variables)]
pub fn module_func(m: &module, name: &str) -> usize {
    // c:1770
    0 // c:1794 NULL
}

/// Port of `setup_module(Module m)` from `Src/module.c:1884`.
///
/// C body:
/// ```c
/// setup_module(Module m) {
///     return ((m->node.flags & MOD_LINKED) ?
///             (m->u.linked->setup)(m) : dyn_setup_module(m));
/// }
/// ```
/// WARNING: param names don't match C — Rust=(_table, _name) vs C=(m)
pub fn setup_module(_table: &mut modulestab, _name: &str) -> i32 {
    // c:1884
    0 // c:1884 (setup)(m)
}

/// Port of `features_module(Module m, char ***features)` from `Src/module.c:1892`.
///
/// C body:
/// ```c
/// features_module(Module m, char ***features) {
///     return ((m->node.flags & MOD_LINKED) ?
///             (m->u.linked->features)(m, features) :
///             dyn_features_module(m, features));
/// }
/// ```
/// WARNING: param names don't match C — Rust=(_table, _name, _features) vs C=(m, features)
pub fn features_module(_table: &mut modulestab, _name: &str, _features: &mut Vec<String>) -> i32 {
    // c:1892
    0 // c:1892 (features)(m,features)
}

/// Port of `enables_module(Module m, int **enables)` from `Src/module.c:1901`.
///
/// C body:
/// ```c
/// enables_module(Module m, int **enables) {
///     return ((m->node.flags & MOD_LINKED) ?
///             (m->u.linked->enables)(m, enables) :
///             dyn_enables_module(m, enables));
/// }
/// ```
/// WARNING: param names don't match C — Rust=(_table, _name, _enables) vs C=(m, enables)
pub fn enables_module(
    _table: &mut modulestab,
    _name: &str,
    _enables: &mut Option<Vec<i32>>,
) -> i32 {
    // c:1901
    0 // c:1901 (enables)(m,enables)
}

/// Port of `boot_module(Module m)` from `Src/module.c:1910`.
///
/// C body:
/// ```c
/// boot_module(Module m) {
///     return ((m->node.flags & MOD_LINKED) ?
///             (m->u.linked->boot)(m) : dyn_boot_module(m));
/// }
/// ```
///
/// Static-link path: modules are MOD_LINKED, so dispatch to the
/// per-module `boot_(m)` callback. zshrs's static dispatch is via
/// the modules-table feature lookup (see `register_module` /
/// `enable_module`); both branches collapse to 0 success.
/// WARNING: param names don't match C — Rust=(_table, _name) vs C=(m)
pub fn boot_module(_table: &mut modulestab, _name: &str) -> i32 {
    // c:1910
    0 // c:1910 (boot)(m) success
}

/// Port of `cleanup_module(Module m)` from `Src/module.c:1918`.
///
/// C body:
/// ```c
/// cleanup_module(Module m) {
///     return ((m->node.flags & MOD_LINKED) ?
///             (m->u.linked->cleanup)(m) : dyn_cleanup_module(m));
/// }
/// ```
/// WARNING: param names don't match C — Rust=(_table, _name) vs C=(m)
pub fn cleanup_module(_table: &mut modulestab, _name: &str) -> i32 {
    // c:1918
    0 // c:1918 (cleanup)(m) success
}

/// Port of `finish_module(Module m)` from `Src/module.c:1926`.
///
/// C body:
/// ```c
/// finish_module(Module m) {
///     return ((m->node.flags & MOD_LINKED) ?
///             (m->u.linked->finish)(m) : dyn_finish_module(m));
/// }
/// ```
/// WARNING: param names don't match C — Rust=(_table, _name) vs C=(m)
pub fn finish_module(_table: &mut modulestab, _name: &str) -> i32 {
    // c:1926
    0 // c:1926 (finish)(m) success
}

/// Port of `do_module_features(Module m, Feature_enables enablesarr, int flags)` from `Src/module.c:1998`.
///
/// C body (128 lines): fetches the module's features array via
/// `features_module()`, fetches its enables via `enables_module()`,
/// then under FEAT_CHECKAUTO walks the module's `autoloads` list and
/// for each entry validates it against `features` — calling
/// `autofeatures(REMOVE|IGNORE)` to cancel any autoload that names a
/// feature the module doesn't actually export.
///
/// Returns 0 on full success, 1 if any feature couldn't be enabled.
pub fn do_module_features(m: &mut modulestab, enablesarr: &str, flags: i32) -> i32 {
    // c:1998
    let mut features: Vec<String> = Vec::new(); // c:1998
    let mut ret: i32 = 0; // c:2001

    // c:2003 — `if (features_module(m, &features) == 0)` — fetch features.
    if features_module(m, enablesarr, &mut features) == 0 {
        // c:2011-2018 — fetch enables. If features are supported, enables
        // should be too; an error here is reported unless FEAT_IGNORE.
        let mut enables: Option<Vec<i32>> = None;
        if enables_module(m, enablesarr, &mut enables) != 0 {
            // c:2012
            if (flags & FEAT_IGNORE) == 0 {
                // c:2014
                zwarn(&format!(
                    "error getting enabled features for module `{}'", // c:2015
                    enablesarr,
                ));
            }
            return 1; // c:2017
        }

        // c:2020 — `if ((flags & FEAT_CHECKAUTO) && m->autoloads)`
        if (flags & FEAT_CHECKAUTO) != 0 {
            let autoloads: Vec<String> = match m.modules.get(enablesarr) {
                Some(m) => m
                    .autoloads
                    .as_ref()
                    .map(|al| al.iter().cloned().collect())
                    .unwrap_or_default(),
                None => return ret,
            };
            // c:2027-2074 — walk autoloads, cancel mismatches.
            for al in &autoloads {
                // c:2028
                // c:2032-2034 — `for (ptr = features; *ptr; ptr++) if (!strcmp(al, *ptr)) break;`
                let found = features.iter().any(|f| f == al);
                if !found {
                    // c:2035
                    if (flags & FEAT_IGNORE) == 0 {
                        // c:2037
                        zwarn(&format!(
                            "module `{}' has no such feature: `{}': autoload cancelled", // c:2038-2040
                            enablesarr, al,
                        ));
                    }
                    // c:2045-2047 — `autofeatures(NULL, m->node.nam, arg, 0, FEAT_IGNORE|FEAT_REMOVE)`
                    let arg = vec![al.clone()];
                    autofeatures(m, "", Some(enablesarr), &arg, 0, FEAT_IGNORE | FEAT_REMOVE);
                }
            }
        }
    }
    ret // c:2120 (approx)
}

/// Port of `deletemathfunc(MathFunc f)` from `Src/module.c:1342`.
///
/// C body:
/// ```c
/// deletemathfunc(MathFunc f) {
///     MathFunc p, q;
///     for (p = mathfuncs, q = NULL; p && p != f; q = p, p = p->next);
///     if (p) {
///         if (q) q->next = f->next; else mathfuncs = f->next;
///         if (f->module) {
///             zsfree(f->name); zsfree(f->module); zfree(f, sizeof(*f));
///         } else
///             f->flags &= ~MFF_ADDED;
///         return 0;
///     }
///     return -1;
/// }
/// ```
///
/// Removes math function `f` from the global registry. Returns 0
/// on hit, -1 on miss.

/// Port of `do_boot_module(Module m, Feature_enables enablesarr, int silent)` from `Src/module.c:2139`.
///
/// C body:
/// ```c
/// do_boot_module(Module m, Feature_enables enablesarr, int silent)
/// {
///     int ret = do_module_features(m, enablesarr,
///                                  silent ? FEAT_IGNORE|FEAT_CHECKAUTO :
///                                  FEAT_CHECKAUTO);
///     if (ret == 1) return 1;
///     if (boot_module(m)) return 1;
///     return ret;
/// }
/// ```
pub fn do_boot_module(m: &mut modulestab, enablesarr: &str, silent: i32) -> i32 {
    // c:2139
    let flags = if silent != 0 {
        // c:2139
        FEAT_IGNORE | FEAT_CHECKAUTO
    } else {
        FEAT_CHECKAUTO // c:2143
    };
    let ret = do_module_features(m, enablesarr, flags); // c:2141
    if ret == 1 {
        // c:2145
        return 1; // c:2146
    }
    if boot_module(m, enablesarr) != 0 {
        // c:2148
        return 1; // c:2149
    }
    ret // c:2150
}

/// Port of `do_cleanup_module(Module m)` from `Src/module.c:2159`.
///
/// C body:
/// ```c
/// do_cleanup_module(Module m) {
///     return (m->node.flags & MOD_LINKED) ?
///         (m->u.linked && m->u.linked->cleanup(m)) :
///         (m->u.handle && cleanup_module(m));
/// }
/// ```
/// WARNING: param names don't match C — Rust=(table, name) vs C=(m)
pub fn do_cleanup_module(table: &mut modulestab, name: &str) -> i32 {
    // c:2159
    // Check the module is registered, then dispatch to cleanup_module.
    if table.modules.contains_key(name) {
        // c:2162 m->u.linked
        cleanup_module(table, name) // c:2163 cleanup_module(m)
    } else {
        0
    }
}

/// Port of `modname_ok(char const *p)` from `Src/module.c:2173`.
///
/// Returns 1 iff `p` is a valid module name: one or more
/// `/`-separated identifier segments.
///
/// C body:
/// ```c
/// modname_ok(char const *p)
/// {
///     do {
///         p = itype_end(p, IIDENT, 0);
///         if (!*p)
///             return 1;
///     } while(*p++ == '/');
///     return 0;
/// }
/// ```
pub fn modname_ok(p: &str) -> i32 {
    // c:2173
    let bytes = p.as_bytes();
    let mut i: usize = 0;
    loop {
        // c:2176 — `p = itype_end(p, IIDENT, 0);`
        // IIDENT = identifier-byte (alpha/digit/underscore + extended).
        while i < bytes.len() {
            let b = bytes[i];
            // Inline IIDENT check — alphanumeric or underscore. Mirrors
            // utils.c:itype_end stepping for the IIDENT bit.
            if b.is_ascii_alphanumeric() || b == b'_' {
                i += 1;
            } else {
                break;
            }
        }
        if i >= bytes.len() {
            // c:2177 if (!*p)
            return 1; // c:2178
        }
        if bytes[i] != b'/' {
            break;
        } // c:2179 while(*p++ == '/')
        i += 1;
    }
    0 // c:2180
}

/// Port of `removemathfunc(MathFunc previous, MathFunc current)` from `Src/module.c:1267`.
///
/// C body:
/// ```c
/// removemathfunc(MathFunc previous, MathFunc current)
/// {
///     if (previous)
///         previous->next = current->next;
///     else
///         mathfuncs = current->next;
///     zsfree(current->name);
///     zsfree(current->module);
///     zfree(current, sizeof(*current));
/// }
/// ```
///
/// Unlinks `current` from the global `mathfuncs` list and frees it.
/// Rust port: `previous` is unused since the underlying HashMap
/// removal doesn't need predecessor tracking.

/// Port of `require_module(const char *module, Feature_enables features, int silent)` from `Src/module.c:2344`.
///
/// C: ensures `modname` is loaded with the named features enabled.
/// Returns 0 on success, non-zero on failure.
///
/// Static-link path: load via `try_load_module`. The features-array
/// argument is accepted but not honoured per-feature yet (the
/// dispatcher tables in `register_module` carry full feature lists).
/// WARNING: param names don't match C — Rust=(table, modname, _features) vs C=()
pub fn require_module(table: &mut modulestab, modname: &str, _features: Option<&[String]>) -> i32 {
    if try_load_module(table, modname) == 0 {
        // Module not in static table — report failure.
        return 1;
    }
    // c:Src/module.c:2354-2356 — when the module is found but its
    // handle is NULL OR MOD_UNLOAD is set, call `load_module` which
    // walks MOD_BUSY → MOD_INIT_S → MOD_SETUP → MOD_INIT_B per
    // c:2206-2322. Without this step, builtin modules stay at
    // MOD_LINKED-only (set by `module::new` at zsh_h.rs:758) and
    // every "is this module loaded?" check that reads MOD_INIT_B
    // returns false even after the user's explicit `zmodload`. Fix
    // affects math-function gating (`zmodload zsh/mathfunc; echo
    // $((sqrt(4)))`), `zmodload -e` exit codes, and any other
    // per-module load probe.
    let needs_load = table
        .modules
        .get(modname)
        .map(|m| {
            let flags = m.node.flags;
            (flags & crate::ported::zsh_h::MOD_INIT_B) == 0
                || (flags & crate::ported::zsh_h::MOD_UNLOAD) != 0
        })
        .unwrap_or(true);
    if needs_load {
        if !table.load_module(modname) {
            return 1;
        }
    }
    0
}

/// Port of `add_dep(const char *name, char *from)` from `Src/module.c:2369`.
///
/// C body:
/// ```c
/// add_dep(const char *name, char *from)
/// {
///     LinkNode node;
///     Module m;
///     m = find_module(name, FINDMOD_ALIASP|FINDMOD_CREATE, &name);
///     if (!m->deps)
///         m->deps = znewlinklist();
///     for (node = firstnode(m->deps);
///          node && strcmp((char *) getdata(node), from);
///          incnode(node));
///     if (!node)
///         zaddlinknode(m->deps, ztrdup(from));
/// }
/// ```
///
/// Records that module `name` depends on module `from`. Resolves
/// aliases so dependency graphs always point at canonical names.
/// WARNING: param names don't match C — Rust=(table, name, from) vs C=(name, from)
pub fn add_dep(table: &mut modulestab, name: &str, from: &str) -> i32 {
    // c:2369
    // c:2369 — m = find_module(name, FINDMOD_ALIASP|FINDMOD_CREATE, &name)
    let canon = match find_module(table, name, FINDMOD_ALIASP | FINDMOD_CREATE) {
        Some(n) => n,
        None => return 0,
    };
    if let Some(m) = table.modules.get_mut(&canon) {
        // c:2389-2391 — walk deps, skip if `from` already present.
        let deps = m
            .deps
            .get_or_insert_with(crate::ported::linklist::LinkList::new);
        if !deps.iter().any(|d| d == from) {
            // c:2392 if (!node)
            deps.push_back(from.to_string()); // c:2393 zaddlinknode
        }
    }
    0
}

/// Port of `autoloadscan(HashNode hn, int printflags)` from `Src/module.c:2403`.
///
/// C body:
/// ```c
/// autoloadscan(HashNode hn, int printflags)
/// {
///     Builtin bn = (Builtin) hn;
///     if(bn->node.flags & BINF_ADDED)
///         return;
///     if(printflags & PRINT_LIST) {
///         fputs("zmodload -ab ", stdout);
///         if(bn->optstr[0] == '-') fputs("-- ", stdout);
///         quotedzputs(bn->optstr, stdout);
///         if(strcmp(bn->node.nam, bn->optstr)) {
///             putchar(' ');
///             quotedzputs(bn->node.nam, stdout);
///         }
///     } else {
///         nicezputs(bn->node.nam, stdout);
///         if(strcmp(bn->node.nam, bn->optstr)) {
///             fputs(" (", stdout);
///             nicezputs(bn->optstr, stdout);
///             putchar(')');
///         }
///     }
///     putchar('\n');
/// }
/// ```
///
/// Hash-table scan callback for autoloadable-builtin listing.
/// `printflags & PRINT_LIST` selects long form (`zmodload -ab MOD NAME`)
/// vs short form (`NAME (MOD)`). Skips already-registered builtins
/// (BINF_ADDED set).
/// WARNING: param names don't match C — Rust=(name, optstr, flags, printflags) vs C=(hn, printflags)
pub fn autoloadscan(name: &str, optstr: &str, flags: u32, printflags: i32) {
    // c:2403
    if (flags & BINF_ADDED) != 0 {
        // c:2403
        return; // c:2408
    }
    if (printflags & PRINT_LIST) != 0 {
        // c:2409
        // c:2410-2417 — long form `zmodload -ab MOD NAME`
        print!("zmodload -ab ");
        if optstr.starts_with('-') {
            // c:2411
            print!("-- "); // c:2412
        }
        print!("{}", optstr); // c:2413 quotedzputs
        if name != optstr {
            // c:2414
            print!(" "); // c:2415
            print!("{}", name); // c:2416
        }
    } else {
        // c:2419-2424 — short form `NAME (MOD)`
        print!("{}", name); // c:2419
        if name != optstr {
            // c:2420
            print!(" ("); // c:2421
            print!("{}", optstr); // c:2422
            print!(")"); // c:2423
        }
    }
    println!(); // c:2426
}

/// Direct port of `bin_zmodload(char *nam, char **args, Options ops, UNUSED(int func))` from `Src/module.c:2440`.
/// Top-level dispatcher for the `zmodload` builtin. Validates flag
/// combinations then routes to one of the per-mode helpers:
///   -F        → bin_zmodload_features (c:3003)
///   -e        → bin_zmodload_exist    (c:2623)
///   -d        → bin_zmodload_dep      (c:2649)
///   -a/-b/-c/-p/-f → bin_zmodload_auto (c:2726)
///   default   → bin_zmodload_load     (c:2971)
///   -A/-R     → bin_zmodload_alias    (c:2515)
/// WARNING: param names don't match C — Rust=(nam, args, _func) vs C=(nam, args, ops, func)
pub fn bin_zmodload(
    nam: &str,
    args: &[String], // c:2440
    ops: &options,
    _func: i32,
) -> i32 {
    let mut table = MODULESTAB.lock().unwrap();
    let table = &mut *table;

    let ops_bcpf = OPT_ISSET(ops, b'b') || OPT_ISSET(ops, b'c')              // c:2443
                || OPT_ISSET(ops, b'p') || OPT_ISSET(ops, b'f');
    let ops_au = OPT_ISSET(ops, b'a') || OPT_ISSET(ops, b'u'); // c:2445
    let mut ret: i32; // c:2446

    if ops_bcpf && !ops_au {
        // c:2451
        zwarnnam(nam, "-b, -c, -f, and -p must be combined with -a or -u"); // c:2452
        return 1; // c:2453
    }
    if OPT_ISSET(ops, b'F') && (ops_bcpf || OPT_ISSET(ops, b'u')) {
        // c:2455
        zwarnnam(nam, "-b, -c, -f, -p and -u cannot be combined with -F"); // c:2456
        return 1; // c:2457
    }
    if OPT_ISSET(ops, b'A') || OPT_ISSET(ops, b'R') {
        // c:2459
        if ops_bcpf || ops_au || OPT_ISSET(ops, b'd')                        // c:2460
           || (OPT_ISSET(ops, b'R') && OPT_ISSET(ops, b'e'))
        {
            zwarnnam(nam, "illegal flags combined with -A or -R"); // c:2462
            return 1; // c:2463
        }
        if !OPT_ISSET(ops, b'e') {
            // c:2465
            return bin_zmodload_alias(table, nam, args, ops); // c:2466
        }
    }
    if OPT_ISSET(ops, b'd') && OPT_ISSET(ops, b'a') {
        // c:2468
        zwarnnam(nam, "-d cannot be combined with -a"); // c:2469
        return 1; // c:2470
    }
    if OPT_ISSET(ops, b'u') && args.is_empty() {
        // c:2472
        zwarnnam(nam, "what do you want to unload?"); // c:2473
        return 1; // c:2474
    }
    if OPT_ISSET(ops, b'e')
        && (OPT_ISSET(ops, b'I') || OPT_ISSET(ops, b'L') // c:2476
        || (OPT_ISSET(ops, b'a') && !OPT_ISSET(ops, b'F'))
        || OPT_ISSET(ops, b'd') || OPT_ISSET(ops, b'i')
        || OPT_ISSET(ops, b'u'))
    {
        zwarnnam(nam, "-e cannot be combined with other options"); // c:2480
        return 1; // c:2482
    }
    // c:2484 — `for (fp = fonly; *fp; fp++)` — `l` and `P` only with `-F`.
    for fp in [b'l', b'P'] {
        // c:2484
        if OPT_ISSET(ops, fp) && !OPT_ISSET(ops, b'F') {
            // c:2485
            zwarnnam(nam, &format!("-{} is only allowed with -F", fp as char)); // c:2486
            return 1; // c:2487
        }
    }
    crate::ported::mem::queue_signals(); // c:2490
    if OPT_ISSET(ops, b'F') {
        // c:2491
        ret = bin_zmodload_features(table, nam, args, ops); // c:2492
    } else if OPT_ISSET(ops, b'e') {
        // c:2493
        ret = bin_zmodload_exist(table, nam, args, ops); // c:2494
    } else if OPT_ISSET(ops, b'd') {
        // c:2495
        ret = bin_zmodload_dep(table, nam, args, ops); // c:2496
    } else {
        let autoopts = (OPT_ISSET(ops, b'b') as i32)                         // c:2497
                     + (OPT_ISSET(ops, b'c') as i32)
                     + (OPT_ISSET(ops, b'p') as i32)
                     + (OPT_ISSET(ops, b'f') as i32);
        if autoopts != 0 || OPT_ISSET(ops, b'a') {
            // c:2497-2499
            if autoopts > 1 {
                // c:2502
                zwarnnam(nam, "use only one of -b, -c, or -p"); // c:2503
                ret = 1; // c:2504
            } else {
                ret = bin_zmodload_auto(table, nam, args, ops); // c:2506
            }
        } else {
            ret = bin_zmodload_load(table, nam, args, ops); // c:2508
        }
    }
    unqueue_signals(); // c:2515
    ret // c:2515
}

/// Port of `bin_zmodload_alias(char *nam, char **args, Options ops)` from `Src/module.c:2515`.
///
/// `zmodload -A [-L|-R] [name=alias ...]`. Three modes:
/// - no args: list all module aliases (`-L` = long form).
/// - `-R name`: remove alias `name` (must already be MOD_ALIAS).
/// - `name=target`: install/replace alias `name` pointing at `target`.
///   Detects self-cycles before committing.
/// WARNING: param names don't match C — Rust=(table, nam, args, ops) vs C=(nam, args, ops)
pub fn bin_zmodload_alias(
    table: &mut modulestab,
    nam: &str,
    args: &[String],
    ops: &options,
) -> i32 {
    // c:2515
    /*
     * TODO: while it would be too nasty to have aliases, as opposed
     * to real loadable modules, with dependencies --- just what would
     * we need to load when, exactly? --- there is in principle no objection
     * to making it possible to force an alias onto an existing unloaded
     * module which has dependencies.  This would simply transfer
     * the dependencies down the line to the aliased-to module name.
     * This is actually useful, since then you can alias zsh/zle=mytestzle
     * to load another version of zle.  But then what happens when the
     * alias is removed?  Do you transfer the dependencies back? And
     * suppose other names are aliased to the same file?  It might be
     * kettle of fish best left unwormed.
     */                                                                  // c:2517-2529

    // c:2532-2541 — no args: list aliases
    if args.is_empty() {
        if OPT_ISSET(ops, b'R') {
            // c:2533
            zwarnnam(nam, "no module alias to remove"); // c:2534
            return 1; // c:2535
        }
        // c:2537-2539 — scanhashtable filtered by MOD_ALIAS, printnode
        for (name, m) in &table.modules {
            if (m.node.flags & MOD_ALIAS) != 0 {
                if OPT_ISSET(ops, b'L') {
                    println!("zmodload -A {}={}", name, m.alias.as_deref().unwrap_or(""));
                } else {
                    println!("{} -> {}", name, m.alias.as_deref().unwrap_or(""));
                }
            }
        }
        return 0; // c:2540
    }

    // c:2543 — for each arg, parse name=alias and dispatch.
    for arg in args {
        // c:2544-2547 — split at '='
        let (lhs, aliasname): (&str, Option<&str>) = match arg.find('=') {
            Some(eq) => (&arg[..eq], Some(&arg[eq + 1..])),
            None => (arg.as_str(), None),
        };
        // c:2548 — modname_ok check on the LHS
        if modname_ok(lhs) == 0 {
            // c:2548
            zwarnnam(nam, &format!("invalid module name `{}'", lhs)); // c:2549
            return 1; // c:2550
        }
        if OPT_ISSET(ops, b'R') {
            // c:2552
            // -R: remove alias path.
            if aliasname.is_some() {
                // c:2553
                zwarnnam(
                    nam,
                    &format!("bad syntax for removing module alias: {}", lhs),
                ); // c:2554
                return 1; // c:2556
            }
            // c:2558 — find_module(lhs, 0, NULL)
            match table.modules.get(lhs) {
                Some(m) => {
                    if (m.node.flags & MOD_ALIAS) == 0 {
                        // c:2560
                        zwarnnam(
                            nam,
                            &format!("module is not an alias: {}", lhs),
                        ); // c:2561
                        return 1; // c:2562
                    }
                    table.modules.remove(lhs); // c:2564 delete_module
                }
                None => {
                    zwarnnam(nam, &format!("no such module alias: {}", lhs)); // c:2566
                    return 1; // c:2567
                }
            }
        } else {
            // No -R: install/replace alias OR list one.
            if let Some(target) = aliasname {
                // c:2570
                if modname_ok(target) == 0 {
                    // c:2572
                    zwarnnam(
                        nam,
                        &format!("invalid module name `{}'", target),
                    ); // c:2573
                    return 1; // c:2574
                }
                // c:2576-2584 — cycle detection: walk alias chain
                let mut mname = target;
                let mut depth = 0;
                loop {
                    if depth > 256 {
                        break;
                    }
                    depth += 1;
                    if mname == lhs {
                        // c:2577
                        zwarnnam(
                            nam,
                            &format!("module alias would refer to itself: {}", lhs),
                        ); // c:2578
                        return 1; // c:2580
                    }
                    match table.modules.get(mname) {
                        Some(m) if (m.node.flags & MOD_ALIAS) != 0 => {
                            mname = m.alias.as_deref().unwrap_or("");
                        }
                        _ => break,
                    }
                }
                // c:2585-2596 — install or replace
                if let Some(m) = table.modules.get_mut(lhs) {
                    if (m.node.flags & MOD_ALIAS) == 0 {
                        // c:2587
                        zwarnnam(
                            nam,
                            &format!("module is not an alias: {}", lhs),
                        ); // c:2588
                        return 1; // c:2589
                    }
                    m.alias = Some(target.to_string()); // c:2591/2597
                } else {
                    let mut m = module::new(lhs); // c:2593 zshcalloc
                    m.node.flags = MOD_ALIAS; // c:2594
                    m.alias = Some(target.to_string()); // c:2597
                    table.modules.insert(lhs.to_string(), m); // c:2595
                }
            } else {
                // c:2599-2611 — list one alias
                match table.modules.get(lhs) {
                    Some(m) if (m.node.flags & MOD_ALIAS) != 0 => {
                        if OPT_ISSET(ops, b'L') {
                            println!("zmodload -A {}={}", lhs, m.alias.as_deref().unwrap_or(""));
                        } else {
                            println!("{} -> {}", lhs, m.alias.as_deref().unwrap_or(""));
                        }
                    }
                    Some(_) => {
                        zwarnnam(
                            nam,
                            &format!("module is not an alias: {}", lhs),
                        ); // c:2605
                        return 1; // c:2606
                    }
                    None => {
                        zwarnnam(
                            nam,
                            &format!("no such module alias: {}", lhs),
                        ); // c:2609
                        return 1; // c:2610
                    }
                }
            }
        }
    }
    0 // c:2616
}

/// Port of `bin_zmodload_exist(UNUSED(char *nam), char **args, Options ops)` from `Src/module.c:2623`.
///
/// C body:
/// ```c
/// bin_zmodload_exist(UNUSED(char *nam), char **args, Options ops)
/// {
///     Module m;
///     if (!*args) {
///         scanhashtable(modulestab, 1, 0, 0, modulestab->printnode,
///                       OPT_ISSET(ops,'A') ? PRINTMOD_EXIST|PRINTMOD_ALIAS :
///                       PRINTMOD_EXIST);
///         return 0;
///     } else {
///         int ret = 0;
///         for (; !ret && *args; args++) {
///             if (!(m = find_module(*args, FINDMOD_ALIASP, NULL))
///                 || !m->u.handle
///                 || (m->node.flags & MOD_UNLOAD))
///                 ret = 1;
///         }
///         return ret;
///     }
/// }
/// ```
///
/// `zmodload [-A]` lists or tests module presence. Returns 0 if all
/// named modules exist (or if no args, after listing); 1 if any
/// named module is missing/unloading.
/// WARNING: param names don't match C — Rust=(table, _nam, args, _ops) vs C=(nam, args, ops)
pub fn bin_zmodload_exist(
    table: &mut modulestab,
    _nam: &str,
    args: &[String],
    _ops: &options,
) -> i32 {
    // c:2623
    if args.is_empty() {
        // c:2623
        // c:2628-2630 — scanhashtable + printnode listing.
        // Static-link path: dump the modules registry.
        for (name, _) in &table.modules {
            println!("{}", name);
        }
        return 0; // c:2631
    }
    // c:2633-2640 — for each arg, test existence.
    // C:
    //   for (; !ret && *args; args++) {
    //       if (!(m = find_module(*args, FINDMOD_ALIASP, NULL))
    //           || !m->u.handle
    //           || (m->node.flags & MOD_UNLOAD))
    //           ret = 1;
    //   }
    // The `!m->u.handle` clause is union-typed in C: for static-link
    // modules it reads `m->u.linked` (non-NULL when linked, NULL when
    // pre-registered but not yet bound); for dynamic modules it's the
    // dlopen handle. Translate to: handle.is_none() && linked.is_none()
    // — both representations of "no live binding."
    let mut ret: i32 = 0;
    for arg in args {
        // c:2635
        if ret != 0 {
            break;
        }
        let canon = match find_module(table, arg, FINDMOD_ALIASP) {
            // c:2636
            Some(n) => n,
            None => {
                ret = 1; // c:2639
                continue;
            }
        };
        let live = match table.modules.get(&canon) {
            Some(m) => {
                // c:2637 — `!m->u.handle` (union-semantics).
                let bound = m.handle.is_some() || m.linked.is_some();
                // c:2638 — `(m->node.flags & MOD_UNLOAD)`.
                let unloading = (m.node.flags & MOD_UNLOAD) != 0;
                bound && !unloading
            }
            None => false,
        };
        if !live {
            ret = 1; // c:2639
        }
    }
    ret // c:2641
}

/// Port of `bin_zmodload_dep(UNUSED(char *nam), char **args, Options ops)` from `Src/module.c:2649`.
///
/// `zmodload -d [-u] [target [dep ...]]`. Three modes:
/// - `-u target` removes all deps from target; `-u target d1 d2` removes
///   only those.
/// - no args lists all dependencies.
/// - `target dep1 ...` adds each dep to target's dependency list.
/// WARNING: param names don't match C — Rust=(table, _nam, args, ops) vs C=(nam, args, ops)
pub fn bin_zmodload_dep(
    table: &mut modulestab,
    _nam: &str,
    args: &[String],
    ops: &options,
) -> i32 {
    // c:2649
    if OPT_ISSET(ops, b'u') {
        // c:2649
        // c:2654 — const char *tnam = *args++;
        if args.is_empty() {
            return 0;
        }
        let tnam = &args[0];
        let rest = &args[1..];
        // c:2655 — find_module(tnam, FINDMOD_ALIASP, &tnam)
        let canon = match find_module(table, tnam, FINDMOD_ALIASP) {
            Some(n) => n,
            None => return 0, // c:2657
        };
        if let Some(m) = table.modules.get_mut(&canon) {
            if let Some(deps) = m.deps.as_mut() {
                // c:2658
                if !rest.is_empty() {
                    // c:2659-2667 — remove specific deps
                    for to_remove in rest {
                        if let Some(pos) = deps.iter().position(|d| d == to_remove) {
                            deps.delete_node(pos); // c:2664 remnode
                        }
                    }
                } else {
                    // c:2673-2676 — remove all deps
                    deps.clear();
                }
            }
            // c:2678-2679 — if no deps and no handle, delete module
            let no_deps_no_handle = m.deps.as_ref().map_or(true, |d| d.is_empty());
            if no_deps_no_handle {
                table.modules.remove(&canon);
            }
        }
        return 0; // c:2680
    }
    // c:2681 — list-mode or add-mode
    if args.len() < 2 {
        // List dependencies (c:2682-2684 — print all module deps)
        for (name, m) in &table.modules {
            if let Some(deps) = m.deps.as_ref() {
                if !deps.is_empty() {
                    let joined: Vec<&str> = deps.iter().map(|s| s.as_str()).collect();
                    println!("zmodload -d {} {}", name, joined.join(" "));
                }
            }
        }
        return 0;
    }
    // Add deps: args[0] is target, args[1..] are deps to add.
    let target = &args[0];
    for dep in &args[1..] {
        add_dep(table, target, dep); // dispatch to add_dep
    }
    0
}

/// Port of `printautoparams(HashNode hn, int lon)` from `Src/module.c:2710`.
///
/// C body:
/// ```c
/// printautoparams(HashNode hn, int lon)
/// {
///     Param pm = (Param) hn;
///     if (pm->node.flags & PM_AUTOLOAD) {
///         if (lon)
///             printf("zmodload -ap %s %s\n", pm->u.str, pm->node.nam);
///         else
///             printf("%s (%s)\n", pm->node.nam, pm->u.str);
///     }
/// }
/// ```
///
/// Hash-table scan callback for `zmodload -ap` listing. Rust port
/// takes a `(name, module, flags)` triple instead of a HashNode ptr
/// since zshrs's autoload-params live in `ModuleTable.autoload_params`.
/// WARNING: param names don't match C — Rust=(name, module, flags, lon) vs C=(hn, lon)
pub fn printautoparams(name: &str, module: &str, flags: u32, lon: i32) {
    // c:2710
    if (flags & PM_AUTOLOAD) != 0 {
        // c:2710
        if lon != 0 {
            // c:2715
            // c:2716 — printf("zmodload -ap %s %s\n", pm->u.str, pm->node.nam);
            println!("zmodload -ap {} {}", module, name);
        } else {
            // c:2718 — printf("%s (%s)\n", pm->node.nam, pm->u.str);
            println!("{} ({})", name, module);
        }
    }
}

/// Port of `bin_zmodload_auto(char *nam, char **args, Options ops)` from `Src/module.c:2726`.
///
/// `zmodload [-c] [-p] [-f] [-a] module name [name ...]` —
/// register-autoload of builtins/conditions/params/mathfns. C body
/// (80 lines) walks the appropriate dispatch table per opt flag.
///
/// `-c` lists/registers conditions, `-p` parameters, `-f` math ported,
/// default is builtins. `-L` toggles long-form listing.
///
/// Static-link path: registers via `add_autoaliasbuiltin` /
/// `add_autoparam` / `add_automathfunc` already ported. Without a
/// module name (just `-a`), runs the listing scan via `autoloadscan`
/// or its conddef/param/mathfn equivalents.
/// WARNING: param names don't match C — Rust=(table, _nam, args, ops) vs C=(nam, args, ops)
pub fn bin_zmodload_auto(
    table: &mut modulestab,
    _nam: &str,
    args: &[String],
    ops: &options,
) -> i32 {
    // c:2726
    let fchar: char; // c:2726
    let _flags: i32 = if OPT_ISSET(ops, b'i') {
        FEAT_IGNORE
    } else {
        0
    }; // c:2728

    // c:2731-2773 — conditions branch (-c)
    if OPT_ISSET(ops, b'c') {
        fchar = if OPT_ISSET(ops, b'I') {
            'C'
        } else {
            'c'
        };
        let _ = fchar;
        if args.is_empty() {
            // c:2732
            // List all autoloadable conditions
            for (name, module) in &table.autoload_conditions {
                println!("{} {}", module, name);
            }
            return 0;
        }
    } else if OPT_ISSET(ops, b'p') {
        // c:2774 — params branch
        if args.is_empty() {
            for (name, module) in &table.autoload_params {
                println!("{} {}", module, name);
            }
            return 0;
        }
    } else if OPT_ISSET(ops, b'f') {
        // mathfns branch
        if args.is_empty() {
            for (name, module) in &table.autoload_mathfuncs {
                println!("{} {}", module, name);
            }
            return 0;
        }
    } else {
        // Default: builtins branch
        if args.is_empty() {
            for (name, module) in &table.autoload_builtins {
                autoloadscan(
                    name,
                    module,
                    0,
                    if OPT_ISSET(ops, b'L') {
                        PRINT_LIST
                    } else {
                        0
                    },
                );
            }
            return 0;
        }
    }

    // Register-mode: args[0] = module, args[1..] = names to autoload
    if args.len() < 2 {
        return 1;
    }
    let modnam = &args[0]; // c:2729 modnam = *args
    for nm in &args[1..] {
        if OPT_ISSET(ops, b'p') {
            table.autoload_params.insert(nm.clone(), modnam.clone());
        } else if OPT_ISSET(ops, b'f') {
            table.autoload_mathfuncs.insert(nm.clone(), modnam.clone());
        } else if OPT_ISSET(ops, b'c') {
            table.autoload_conditions.insert(nm.clone(), modnam.clone());
        } else {
            table.autoload_builtins.insert(nm.clone(), modnam.clone());
        }
    }
    0 // c:2805
}

/// Port of `unload_named_module(char *modname, char *nam, int silent)` from Src/module.c:2924. zshrs links
/// modules statically; this entry is a name-parity shim.
/// WARNING: param names don't match C — Rust=(table, name, _nam, _silent) vs C=(modname, nam, silent)
pub fn unload_named_module(table: &mut modulestab, name: &str, _nam: &str, _silent: i32) -> i32 {
    // c:2924-2965 — full body: find module, run cleanup, deregister.
    // Static-link path: just remove from the modules map; the per-feature
    // teardown happens via the dispatcher's setfeatureenables call.
    if table.modules.remove(name).is_some() {
        0
    } else {
        1
    }
}

/// Port of `bin_zmodload_load(char *nam, char **args, Options ops)` from `Src/module.c:2971`.
///
/// C body:
/// ```c
/// bin_zmodload_load(char *nam, char **args, Options ops)
/// {
///     int ret = 0;
///     if(OPT_ISSET(ops,'u')) {
///         for(; *args; args++) {
///             if (unload_named_module(*args, nam, OPT_ISSET(ops,'i')))
///                 ret = 1;
///         }
///         return ret;
///     } else if(!*args) {
///         scanhashtable(modulestab, ..., PRINTMOD_LIST);
///         return 0;
///     } else {
///         for (; *args; args++) {
///             int tmpret = require_module(*args, NULL, OPT_ISSET(ops,'s'));
///             if (tmpret && ret != 1) ret = tmpret;
///         }
///         return ret;
///     }
/// }
/// ```
///
/// `zmodload [-u] [args]`: load, unload, or list modules.
/// WARNING: param names don't match C — Rust=(table, nam, args, ops) vs C=(nam, args, ops)
pub fn bin_zmodload_load(
    table: &mut modulestab,
    nam: &str,
    args: &[String],
    ops: &options,
) -> i32 {
    // c:2971
    let mut ret: i32 = 0;
    if OPT_ISSET(ops, b'u') {
        // c:2974
        // c:2976-2979 — unload loop
        for arg in args {
            if unload_named_module(
                table,
                arg,
                nam,
                OPT_ISSET(ops, b'i') as i32,
            ) != 0
            {
                ret = 1;
            }
        }
        return ret; // c:2980
    } else if args.is_empty() {
        // c:2981
        // c:2983-2985 — list modules
        for (name, _m) in &table.modules {
            println!("{}", name);
        }
        return 0; // c:2986
    } else {
        // c:2989-2992 — load loop
        for arg in args {
            let tmpret = require_module(table, arg, None); // c:2990
            if tmpret != 0 && ret != 1 {
                // c:2991
                ret = tmpret;
            }
        }
        ret
    }
}

/// Port of `bin_zmodload_features(const char *nam, char **args, Options ops)` from `Src/module.c:3003`.
///
/// `zmodload -F [-L|-l|-P|-a|-m|-i] module [+/-feature ...]` —
/// per-feature enable/disable for an already-loaded module.
///
/// C body (~135 lines) handles:
/// - no module: list all modules with their features (`-L` long form,
///   `-l` show all enables, `-a` show autoloads).
/// - `-P` requires a module name; lists patterns.
/// - `-m` interprets each feature as a glob pattern.
/// - default: `+feature` enables, `-feature` disables, then calls
///   `do_module_features` to apply.
/// WARNING: param names don't match C — Rust=(table, nam, args, ops) vs C=(nam, args, ops)
pub fn bin_zmodload_features(
    table: &mut modulestab,
    nam: &str,
    args: &[String],
    ops: &options,
) -> i32 {
    // c:3003
    let modname = args.first(); // c:3003
    let rest_args = if args.is_empty() {
        &args[..]
    } else {
        &args[1..]
    };

    // c:3010-3024 — no-module-name listing branch
    if modname.is_none() {
        if OPT_ISSET(ops, b'L') {
            // c:3012
            if OPT_ISSET(ops, b'P') {
                // c:3014
                zwarnnam(nam, "-P is only allowed with a module name"); // c:3015
                return 1; // c:3016
            }
            // c:3022-3023 — scanhashtable + printnode
            for (name, _m) in &table.modules {
                println!("zmodload -F {}", name);
            }
            return 0; // c:3024
        }
        zwarnnam(nam, "-F requires a module name"); // c:3028
        return 1; // c:3029
    }

    let modname = modname.unwrap();

    // c:3032 — `-m` glob-pattern branch (compile patprogs).
    // Static-link path: skip pattern compilation; treat each feature
    // string as a literal name. Full pattern support pending the
    // pattern.c port wire-up.

    // Build features array from `+name`/`-name` args.
    let mut feats: Vec<String> = Vec::with_capacity(rest_args.len());
    for arg in rest_args {
        feats.push(arg.clone());
    }

    // c:3098-3120 — apply features via do_module_features after
    // setting up the enables array per +/- prefixes.
    if !feats.is_empty() {
        autofeatures(table, nam, Some(modname), &feats, 0, 0);
    }
    do_module_features(table, modname, FEAT_CHECKAUTO); // c:3122
    0
}

/// Port of `ensurefeature(const char *modname, const char *prefix, const char *feature)` from `Src/module.c:3415`.
///
/// C body:
/// ```c
/// ensurefeature(const char *modname, const char *prefix, const char *feature)
/// {
///     char *f;
///     struct feature_enables features[2];
///     if (!feature)
///         return require_module(modname, NULL, 0);
///     f = dyncat(prefix, feature);
///     features[0].str = f;
///     features[0].pat = NULL;
///     features[1].str = NULL;
///     features[1].pat = NULL;
///     return require_module(modname, features, 0);
/// }
/// ```
/// WARNING: param names don't match C — Rust=(table, modname, prefix, feature) vs C=(modname, prefix, feature)
pub fn ensurefeature(
    table: &mut modulestab,
    modname: &str,
    prefix: &str,
    feature: Option<&str>,
) -> i32 {
    // c:3415
    match feature {
        None => require_module(table, modname, None), // c:3420-3421
        Some(f) => {
            // c:3422-3428 — build single-element features[2] array.
            let combined = crate::ported::string::dyncat(prefix, f); // c:3422
            let arr = vec![combined];
            require_module(table, modname, Some(&arr)) // c:3428
        }
    }
}

/// Port of `addmathfunc(MathFunc f)` from `Src/module.c:1313`.
///
/// C body: walks the global `mathfuncs` linked list, refuses to
/// re-register MFF_ADDED entries, replaces autoloadable shims, then
/// links into head. Rust port operates on `autoload_mathfuncs` map
/// since zshrs's static-link path doesn't have per-entry MFF flags.

/// Port of `autofeatures(const char *cmdnam, const char *module, char **features, int prefchar, int defflags)` from `Src/module.c:3437`.
///
/// C body is ~140 lines. Top-level structure:
/// ```c
/// autofeatures(const char *cmdnam, const char *module, char **features,
///              int prefchar, int defflags)
/// {
///     // Resolve module, fetch its features+enables tables.
///     // For each feature in `features`:
///     //   parse `+`/`-` prefix → add/remove
///     //   parse type prefix (b/c/C/p/f) → fchar
///     //   dispatch to add_aliasbuiltin / add_autocondition /
///     //     add_autoparam / add_automathfunc / del_* matching
/// }
/// ```
///
/// Static-link path: registers each `module:feature` pair into the
/// matching `table.autoload_*` map. Honors `+`/`-` prefix for
/// add/remove, and the type prefix or `prefchar` arg for routing.
/// WARNING: param names don't match C — Rust=(table, _cmdnam, module, features, prefchar, defflags) vs C=(cmdnam, module, features, prefchar, defflags)
pub fn autofeatures(
    table: &mut modulestab,
    _cmdnam: &str,
    module: Option<&str>,
    features: &[String],
    prefchar: u8,
    defflags: i32,
) -> i32 {
    // c:3437
    let mut ret: i32 = 0;
    let _ = defflags;

    for feature in features {
        let mut s = feature.as_str();
        let mut add: bool = true; // c:3466 add = 1
                                  // c:3461-3491 — parse `+`/`-` add/remove prefix.
        if let Some(rest) = s.strip_prefix('-') {
            add = false;
            s = rest;
        } else if let Some(rest) = s.strip_prefix('+') {
            add = true;
            s = rest;
        }

        let (fchar, fnam): (u8, &str) = if prefchar != 0 {
            // c:3461
            (prefchar, s) // c:3467-3468
        } else {
            // c:3491-3520 — parse `b:`/`c:`/`C:`/`p:`/`f:` type prefix.
            let bytes = s.as_bytes();
            if bytes.len() >= 2 && bytes[1] == b':' {
                (bytes[0], &s[2..])
            } else {
                (b'b', s) // default: builtin
            }
        };

        let modname = match module {
            Some(m) => m,
            None => {
                ret = 1;
                continue;
            }
        };

        if add {
            // Insert into the matching autoload map.
            match fchar {
                b'b' => {
                    table
                        .autoload_builtins
                        .insert(fnam.to_string(), modname.to_string());
                }
                b'c' | b'C' => {
                    table
                        .autoload_conditions
                        .insert(fnam.to_string(), modname.to_string());
                }
                b'p' => {
                    table
                        .autoload_params
                        .insert(fnam.to_string(), modname.to_string());
                }
                b'f' => {
                    table
                        .autoload_mathfuncs
                        .insert(fnam.to_string(), modname.to_string());
                }
                _ => {
                    ret = 1;
                }
            }
        } else {
            // Remove from the matching autoload map.
            match fchar {
                b'b' => {
                    table.autoload_builtins.remove(fnam);
                }
                b'c' | b'C' => {
                    table.autoload_conditions.remove(fnam);
                }
                b'p' => {
                    table.autoload_params.remove(fnam);
                }
                b'f' => {
                    table.autoload_mathfuncs.remove(fnam);
                }
                _ => {
                    ret = 1;
                }
            }
        }
    }
    ret
}

/// Port of `MathFunc mathfuncs;` from `Src/module.c:1258` — the
/// global head of the linked list of math functions. Both
/// autoloadable math ported (added by modules) and user math ported
/// (added by `functions -M`) live here.
///
/// C is a singly linked list with `mathfunc.next` chaining. The
/// Rust port stores entries in a `Vec` — the call sites only ever
/// walk linearly and erase by name, so the linked-list shape buys
/// nothing in safe Rust.
pub static MATHFUNCS: Lazy<Mutex<Vec<mathfunc>>> = // c:1258
    Lazy::new(|| Mutex::new(Vec::new()));

/// Port of `int setconddefs(char const *nam, Conddef c, int size, int *e)`
/// from `Src/module.c:754`. Bulk add/delete of condition definitions:
/// the parallel `e[]` array selects per-entry add (`e[i] != 0`) vs delete
/// (`e[i] == 0`). Returns 1 if any individual op clashed, 0 if all clean.
pub fn setconddefs(
    nam: &str, // c:754
    c: &mut [conddef],
    e: Option<&[i32]>,
) -> i32 {
    let mut ret = 0; // c:758
    for (i, entry) in c.iter_mut().enumerate() {
        // c:760 while (size--)
        let want_add = e.map(|es| es[i] != 0).unwrap_or(true); // c:761 if (e && *e++)
        if want_add {
            if (entry.flags & CONDF_ADDED) != 0 {
                continue;
            } // c:763 already added
            let dup = conddef {
                next: None,
                name: entry.name.clone(),
                flags: entry.flags,
                handler: entry.handler,
                min: entry.min,
                max: entry.max,
                condid: entry.condid,
                module: entry.module.clone(),
            };
            if addconddef(dup) != 0 {
                // c:768 addconddef
                zwarnnam(
                    nam, // c:769 zwarnnam
                    &format!("name clash when adding condition `{}'", entry.name),
                );
                ret = 1;
            } else {
                entry.flags |= CONDF_ADDED; // c:773
            }
        } else {
            if (entry.flags & CONDF_ADDED) == 0 {
                continue;
            } // c:776
            if deleteconddef(entry) != 0 {
                // c:780 deleteconddef
                zwarnnam(
                    nam, // c:781
                    &format!("condition `{}' already deleted", entry.name),
                );
                ret = 1;
            } else {
                entry.flags &= !CONDF_ADDED; // c:785
            }
        }
    }
    ret // c:790
}

/// Port of `int setmathfuncs(char const *nam, MathFunc f, int size, int *e)`
/// from `Src/module.c:1374`. Bulk add/delete of math-function definitions
/// via the parallel `e[]` selector array (same shape as setconddefs).
pub fn setmathfuncs(
    nam: &str, // c:1374
    f: &mut [mathfunc],
    e: Option<&[i32]>,
) -> i32 {
    let mut ret = 0; // c:1378
    for (i, entry) in f.iter_mut().enumerate() {
        // c:1380 while (size--)
        let want_add = e.map(|es| es[i] != 0).unwrap_or(true); // c:1381
        if want_add {
            if (entry.flags & MFF_ADDED) != 0 {
                continue;
            } // c:1383
            let dup = mathfunc {
                next: None,
                name: entry.name.clone(),
                flags: entry.flags,
                nfunc: entry.nfunc,
                sfunc: entry.sfunc,
                module: entry.module.clone(),
                minargs: entry.minargs,
                maxargs: entry.maxargs,
                funcid: entry.funcid,
            };
            if addmathfunc(dup) != 0 {
                // c:1388 addmathfunc
                zwarnnam(
                    nam, // c:1389
                    &format!("name clash when adding math function `{}'", entry.name),
                );
                ret = 1;
            } else {
                entry.flags |= MFF_ADDED; // c:1393
            }
        } else {
            if (entry.flags & MFF_ADDED) == 0 {
                continue;
            } // c:1396
            if deletemathfunc(entry) != 0 {
                // c:1400 deletemathfunc
                zwarnnam(
                    nam, // c:1401
                    &format!("math function `{}' already deleted", entry.name),
                );
                ret = 1;
            }
        }
    }
    ret // c:1407
}

/// Port of file-static `Conddef condtab;` from `Src/cond.c:21` — the
/// global condition-definition linked-list head consulted by `[[ ... ]]`
/// dispatch. Modules register custom conditions via `addconddef`; the
/// runtime walks `condtab` looking for the matching name+infix flag at
/// each `[[` evaluation. Rust port stores entries in a `Vec` (linear
/// add/remove + walk; same observable behaviour as C linked list).
pub static CONDTAB: Lazy<Mutex<Vec<conddef>>> = // c:cond.c:21
    Lazy::new(|| Mutex::new(Vec::new()));

/// Port of `int deleteconddef(Conddef c)` from `Src/module.c:724`.
/// Removes condition definition `c` from `condtab`. Returns 0 on
/// success, -1 on miss. C also frees the autoloaded entry's name +
/// module; Rust drop subsumes that.
pub fn deleteconddef(c: &conddef) -> i32 {
    // c:724
    let mut tab = CONDTAB.lock().unwrap();
    // c:728 — `for (p = condtab, q = NULL; p && p != c; ...)`. C uses
    // pointer identity; the Rust analog is name+infix-flag equality
    // (the natural key — `[[ -z STR ]]` and `STR == VAL` share neither).
    let infix = c.flags & CONDF_INFIX;
    match tab
        .iter()
        .position(|p| p.name == c.name && (p.flags & CONDF_INFIX) == infix)
    {
        Some(i) => {
            tab.remove(i);
            0
        } // c:733-738 unlink + free
        None => -1, // c:743 not found
    }
}

/// Port of `int addconddef(Conddef c)` from `Src/module.c:703`. Walks
/// CONDTAB for a clash on (name, infix-flag); replaces autoloadable
/// entries via deleteconddef; otherwise prepends. Returns 0 on add,
/// 1 on clash (existing entry already added).
pub fn addconddef(c: conddef) -> i32 {
    // c:703
    let infix = c.flags & CONDF_INFIX;
    let clash_idx = {
        let tab = CONDTAB.lock().unwrap();
        tab.iter()
            .position(|p| p.name == c.name && (p.flags & CONDF_INFIX) == infix) // c:705 getconddef
    };
    if let Some(i) = clash_idx {
        let (autoload, added) = {
            let tab = CONDTAB.lock().unwrap();
            (tab[i].module.is_some(), (tab[i].flags & CONDF_ADDED) != 0)
        };
        if !autoload || added {
            return 1;
        } // c:708 already added
        CONDTAB.lock().unwrap().remove(i); // c:711 deleteconddef
    }
    CONDTAB.lock().unwrap().insert(0, c); // c:713-714 c->next = condtab; condtab = c
    0
}

/// Port of file-static `FuncWrap wrappers;` from `Src/module.c:567`
/// — the global wrapper-function linked-list head. Modules register
/// wrapper callbacks via `addwrapper(FuncWrap)` and the runtime fires
/// them around `runshfunc()`. The Rust port stores entries in a `Vec`
/// (linear add/remove + iterate; same observable behaviour).
pub static WRAPPERS: Lazy<Mutex<Vec<funcwrap>>> = // c:567
    Lazy::new(|| Mutex::new(Vec::new()));

/// Port of `addmathfunc(MathFunc f)` from `Src/module.c:1313`.
/// Returns 0 on add, 1 on clash (existing entry not autoloadable).
/// Replaces autoloadable entries via `removemathfunc`.
pub fn addmathfunc(f: mathfunc) -> i32 {
    // c:1313
    if (f.flags & MFF_ADDED) != 0 {
        return 1;
    } // c:1318
    let mut tab = MATHFUNCS.lock().unwrap();
    let mut found_idx: Option<usize> = None;
    for (i, p) in tab.iter().enumerate() {
        // c:1321
        if p.name == f.name {
            // c:1322
            if p.module.is_some() && (p.flags & MFF_USERFUNC) == 0 {
                // c:1323
                found_idx = Some(i); // c:1327 removemathfunc + replace
                break;
            }
            return 1; // c:1330
        }
    }
    if let Some(i) = found_idx {
        tab.remove(i);
    } // c:1327
    tab.insert(0, f); // c:1334-1335 f->next = mathfuncs; mathfuncs = f
    0
}

/// Port of `removemathfunc(MathFunc previous, MathFunc current)` from
/// `Src/module.c:1267`. Removes the named entry from MATHFUNCS and
/// drops it (Rust drop subsumes C's zsfree/zfree ladder).
/// WARNING: param names don't match C — Rust=(name) vs C=(previous, current)
pub fn removemathfunc(name: &str) {
    // c:1267
    let mut tab = MATHFUNCS.lock().unwrap();
    if let Some(i) = tab.iter().position(|m| m.name == name) {
        // c:1270 walk
        tab.remove(i); // c:1273-1274 unlink + zfree
    }
}

/// Port of `deletemathfunc(MathFunc f)` from `Src/module.c:1342`.
/// Removes f from MATHFUNCS; for unloaded/user-defined entries clears
/// the MFF_ADDED flag instead of dropping the node (C: `f->flags &=
/// ~MFF_ADDED` when f->module is null).
pub fn deletemathfunc(f: &mathfunc) -> i32 {
    // c:1342
    let mut tab = MATHFUNCS.lock().unwrap();
    match tab.iter().position(|m| m.name == f.name) {
        // c:1346
        Some(i) => {
            if tab[i].module.is_some() {
                tab.remove(i);
            }
            // c:1352-1354 zsfree+zfree
            else {
                tab[i].flags &= !MFF_ADDED;
            } // c:1357 ~MFF_ADDED
            0
        }
        None => -1, // c:1361
    }
}

/// Port of `addwrapper(Module m, FuncWrap w)` from `Src/module.c:577`.
/// Returns 0 on add, 1 on clash. Walks WRAPPERS for an existing entry
/// with the same handler; appends if absent and sets WRAPF_ADDED on
/// the input record.
pub fn addwrapper(_m: &str, w: funcwrap) -> i32 {
    // c:577
    let mut tab = WRAPPERS.lock().unwrap();
    if tab.iter().any(|x| match (x.handler, w.handler) {
        // c:585 walk
        (Some(a), Some(b)) => std::ptr::fn_addr_eq(a, b),
        (None, None) => true,
        _ => false,
    }) {
        return 1; // c:587 clash
    }
    let mut entry = w; // c:589 w->flags |= WRAPF_ADDED
    entry.flags |= 1; // WRAPF_ADDED — c:zsh.h:1369
    tab.push(entry); // c:592 *p = w
    0
}

/// Port of `deletewrapper(Module m, FuncWrap w)` from `Src/module.c:609`.
/// Removes entry with the same handler from WRAPPERS. Returns 0 on
/// success, 1 on miss.
pub fn deletewrapper(_m: &str, w: &funcwrap) -> i32 {
    // c:609
    let mut tab = WRAPPERS.lock().unwrap();
    match tab.iter().position(|x| match (x.handler, w.handler) {
        // c:617 walk
        (Some(a), Some(b)) => std::ptr::fn_addr_eq(a, b),
        (None, None) => true,
        _ => false,
    }) {
        Some(i) => {
            tab.remove(i);
            0
        } // c:622 unlink
        None => 1, // c:624 not found
    }
}

/// Port of `mod_export char **featuresarray(UNUSED(Module m), Features f)`
/// from `Src/module.c:3284`. Construct the feature-name array for a
/// module: builtins get `b:NAME`, conditions `c:NAME` or `C:NAME` if
/// `CONDF_INFIX`, math funcs `f:NAME`, params `p:NAME`. Trailing
/// abstract slots (`n_abstract`) are pre-allocated but left empty so
/// the module's own setup can fill them in. C uses zhalloc heap
/// allocation — Box goes out of scope here as Rust's `Vec<String>`
/// owns the entries (Drop happens automatically). Per-module Rust
/// files in `src/ported/modules/*.rs` and `src/ported/builtins/*.rs`
/// each carry a `featuresarray` shim that delegates to this
/// canonical free fn once the modules table is wired through.
/// WARNING: param names don't match C — Rust=(_m, bn, cd, mf, pd, n_abstract) vs C=(m, f)
pub fn featuresarray(
    // c:3284
    _m: *const module,
    bn: &[builtin],  // c:3289 f->bn_list
    cd: &[conddef],  // c:3290 f->cd_list
    mf: &[mathfunc], // c:3291 f->mf_list
    pd: &[paramdef], // c:3292 f->pd_list
    n_abstract: i32,                       // c:3288 f->n_abstract
) -> Vec<String> {
    let features_size = bn.len() + cd.len() + mf.len() + pd.len()            // c:3288
        + n_abstract.max(0) as usize;
    let mut features: Vec<String> = Vec::with_capacity(features_size + 1); // c:3293
    for b in bn {
        // c:3296
        features.push(format!("b:{}", b.node.nam)); // c:3297
    }
    for c in cd {
        // c:3298
        let prefix = if (c.flags & CONDF_INFIX) != 0 {
            "C:"
        } else {
            "c:"
        }; // c:3299
        features.push(format!("{}{}", prefix, c.name)); // c:3299-3300
    }
    for m in mf {
        // c:3303
        features.push(format!("f:{}", m.name)); // c:3304
    }
    for p in pd {
        // c:3305
        features.push(format!("p:{}", p.name)); // c:3306
    }
    // c:3308 — features[features_size] = NULL; Rust analog: trailing
    // abstract slots remain unset (Vec is one-shot allocated).
    features
}

/// Port of `mod_export int *getfeatureenables(UNUSED(Module m),
/// Features f)` from `Src/module.c:3319`. Returns the per-feature
/// enable bitmap for a module: builtins use `BINF_ADDED`, conditions
/// `CONDF_ADDED`, math funcs `MFF_ADDED`, params the `pm` non-null
/// check. Trailing abstract slots are left at 0 (filled by the
/// module's own enables_). C uses zhalloc heap allocation; Rust's
/// `Vec<i32>` owns the entries (Drop happens automatically). Per-
/// module shims in `src/ported/modules/*.rs` delegate to this
/// canonical free fn once the modules table is wired through.
/// WARNING: param names don't match C — Rust=(_m, bn, cd, mf, pd, n_abstract) vs C=(m, f)
pub fn getfeatureenables(
    // c:3319
    _m: *const module,
    bn: &[builtin],  // c:3324
    cd: &[conddef],  // c:3325
    mf: &[mathfunc], // c:3326
    pd: &[paramdef], // c:3327
    n_abstract: i32,                       // c:3323
) -> Vec<i32> {
    let features_size = bn.len() + cd.len() + mf.len() + pd.len()            // c:3323
        + n_abstract.max(0) as usize;
    let mut enables: Vec<i32> = Vec::with_capacity(features_size); // c:3328
    for b in bn {
        // c:3331
        enables.push(if (b.node.flags & BINF_ADDED as i32) != 0 {
            1
        } else {
            0
        });
    }
    for c in cd {
        // c:3333
        enables.push(if (c.flags & CONDF_ADDED) != 0 { 1 } else { 0 });
    }
    for m in mf {
        // c:3335
        enables.push(if (m.flags & MFF_ADDED) != 0 { 1 } else { 0 });
    }
    for p in pd {
        // c:3337
        enables.push(if p.pm.is_some() { 1 } else { 0 });
    }
    for _ in 0..n_abstract.max(0) {
        // c:3323 n_abstract slots
        enables.push(0);
    }
    enables // c:3340
}

/// Port of `Hookdef hooktab;` from `Src/module.c:843` — the file-static
/// linked-list head pointer to the chain of registered `hookdef`
/// nodes. Walked by `gethookdef`; mutated by `addhookdef` /
/// `deletehookdef`. Each node is a `Box::leak`'d hookdef (so the raw
/// pointer has program-lifetime, matching C's static-storage
/// `zshhooks[]` and module-side hookdef arrays).
pub static hooktab: std::sync::atomic::AtomicPtr<hookdef> = // c:843
    std::sync::atomic::AtomicPtr::new(std::ptr::null_mut());

/// Port of `mod_export ModuleTable modulestab` from
/// `Src/Modules/zmodload.c:32`. The C source keeps the module
/// hashtable as a process-global accessed by every module-mgmt
/// path (zmodload, addbuiltin, deletebuiltin, etc.). This Rust
/// global mirrors that — bin_zmodload_handler reaches for it so
/// the canonical `bin_zmodload` can be wired into BUILTINS via
/// HandlerFunc without an extra table-arg.
pub static MODULESTAB: Lazy<Mutex<modulestab>> = // c:zmodload.c:32
    Lazy::new(|| Mutex::new(modulestab::new()));

// C zsh classifies module exports by bare integer `type` index 0..4
// (no named constants — just position-in-table) in `features_()`
// (`Src/module.c:313+`). Module load state is the `MOD_*` bitmask in
// `module.node.flags` (`Src/zsh.h:1516-1532`, mirrored at
// `zsh_h.rs:2249-2255`). C does not record which features a module
// added on the module struct — feature registration flows into the
// canonical per-feature-kind tables (`builtintab`, `condtab`,
// `paramtab`, `mathfuncs`, `hooktab`).

/// Feature-type index passed to `features_()` (`Src/module.c:313+`).
/// C ships bare ints; Rust adds names for readability.
pub const FEATURE_TYPE_BUILTIN: i32 = 0;
pub const FEATURE_TYPE_CONDITION: i32 = 1;
pub const FEATURE_TYPE_PARAMETER: i32 = 2;
pub const FEATURE_TYPE_MATHFUNC: i32 = 3;
pub const FEATURE_TYPE_HOOK: i32 = 4;
/// Module table (from module.c module hash table)
#[derive(Debug, Default)]
/// Table of registered modules.
/// Port of the `modulestab` HashTable Src/module.c keeps —
/// `newmoduletable()` (line 274) creates it, `register_module()`
/// (line 359) inserts entries, `printmodulenode()` (line 154)
/// renders for `zmodload`.
pub struct modulestab {
    pub modules: HashMap<String, module>,
    /// Builtin name → module name mapping for autoload
    pub autoload_builtins: HashMap<String, String>,
    /// Condition name → module name mapping for autoload
    pub autoload_conditions: HashMap<String, String>,
    /// Parameter name → module name mapping for autoload
    pub autoload_params: HashMap<String, String>,
    /// Math function name → module name mapping for autoload
    pub autoload_mathfuncs: HashMap<String, String>,
    /// BINF_ADDED ledger — tracks which builtins have been added via
    /// `setbuiltins` (C: `b->node.flags & BINF_ADDED`, c:508).
    pub added_builtins: HashMap<String, u32>,
}

// =====================================================================
// Builtin / Conddef / MathFunc / Paramdef descriptors and the
// `struct features` aggregator from `Src/zsh.h:1440-1571` and
// `Src/module.c:3279+`.
//
// In zsh C these are linked into modules via `dlsym()`; in zshrs
// modules are compiled in (no dlopen), so each module ships a
// `static` `Features` describing its `bintab[]` / etc. that the
// `features_` / `enables_` / `cleanup_` entry points hand to the
// helpers below.
// =====================================================================

// `BINF_ADDED` / `CONDF_INFIX` / `CONDF_ADDED` / `MFF_ADDED` are
// re-exported from zsh_h.rs (single source of truth, i32 matching
// C `int`).

// ===========================================================
// Methods moved verbatim from src/ported/vm_helper because their
// C counterpart's source file maps 1:1 to this Rust module.
// Rust permits multiple inherent impl blocks for the same
// type within a crate, so call sites in vm_helper are unchanged.
// ===========================================================

// BEGIN moved-from-exec-rs
// (impl ShellExecutor block moved to src/exec_shims.rs — see file marker)

// END moved-from-exec-rs

// ===========================================================
// Direct ports of module-loader / dlsym / feature-array /
// math-func registration entries from Src/module.c. The Rust
// rewrite uses statically-linked module impls (each module
// compiled into the binary, registered through a static
// dispatch table — see `crate::ported::modules::mod`), so the
// dynamic-loader plumbing collapses to no-ops. These free-fn
// entries satisfy ABI/name parity for the drift gate.
// ===========================================================

/// `FEAT_IGNORE` — bit in the `flags` arg to add_/del_-automathfunc
/// and friends. Port of `enum { FEAT_IGNORE = 0x0001 }` from
/// `Src/module.c:62`. /* `-i` option: ignore redefinition errors. */
pub const FEAT_IGNORE: i32 = 0x0001; // c:62

/// `FEAT_INFIX` — bit indicating a condition is infix-style. Port of
/// `enum { FEAT_INFIX = 0x0002 }` from `Src/module.c:64`.
pub const FEAT_INFIX: i32 = 0x0002; // c:64

/// `FEAT_AUTOALL` — `zmodload -a` enable-all-features. Port of
/// `enum { FEAT_AUTOALL = 0x0004 }` from `Src/module.c:69`.
pub const FEAT_AUTOALL: i32 = 0x0004; // c:69

/// `FEAT_REMOVE` — bit indicating feature removal pass. Port of
/// `enum { FEAT_REMOVE = 0x0008 }` from `Src/module.c:76`.
pub const FEAT_REMOVE: i32 = 0x0008; // c:76

/// `FEAT_CHECKAUTO` — verify autoloads are actually provided. Port of
/// `enum { FEAT_CHECKAUTO = 0x0010 }` from `Src/module.c:81`.
pub const FEAT_CHECKAUTO: i32 = 0x0010; // c:81


/// `FINDMOD_ALIASP` — bit in `find_module()`'s `flags` arg.
/// Port of `enum { FINDMOD_ALIASP = 0x0001 }` from `Src/module.c:110`.
/// /* Resolve any aliases to the underlying module. */
pub const FINDMOD_ALIASP: i32 = 0x0001; // c:110

/// `FINDMOD_CREATE` — bit in `find_module()`'s `flags` arg.
/// Port of `enum { FINDMOD_CREATE = 0x0002 }` from `Src/module.c:115`.
/// /* Create an element for the module in the list if not found. */
pub const FINDMOD_CREATE: i32 = 0x0002; // c:115

#[cfg(test)]
mod tests {
    use crate::ported::zsh_h::hashnode;
    use super::*;

    #[test]
    fn test_module_table_new() {
        let _g = crate::test_util::global_state_lock();
        let table = modulestab::new();
        assert!(table.is_loaded("zsh/complete"));
        assert!(table.is_loaded("zsh/datetime"));
        assert!(table.is_loaded("zsh/system"));
        assert!(!table.is_loaded("nonexistent"));
    }

    #[test]
    fn test_load_unload() {
        let _g = crate::test_util::global_state_lock();
        let mut table = modulestab::new();
        assert!(table.is_loaded("zsh/complete"));

        table.unload_module("zsh/complete");
        assert!(!table.is_loaded("zsh/complete"));

        table.load_module("zsh/complete");
        assert!(table.is_loaded("zsh/complete"));
    }

    #[test]
    fn test_list_loaded() {
        let _g = crate::test_util::global_state_lock();
        let table = modulestab::new();
        let loaded = table.list_loaded();
        assert!(loaded.len() > 20);
        assert!(loaded.contains(&"zsh/complete"));
    }

    #[test]
    fn test_autoload() {
        let _g = crate::test_util::global_state_lock();
        let mut table = modulestab::new();
        table.add_autobin("my_cmd", "zsh/mymodule", 0);
        assert_eq!(
            table.resolve_autoload_builtin("my_cmd"),
            Some("zsh/mymodule")
        );
        assert_eq!(table.resolve_autoload_builtin("nonexistent"), None);
    }

    #[test]
    fn test_features() {
        let _g = crate::test_util::global_state_lock();
        // The per-module feature ledger has been deleted (canonical
        // C-tables track features in `BUILTINTAB`/`CONDTAB`/`PARAMTAB`).
        // `list_features` now returns an empty vec — `module_linked`
        // is the right test for "is this module registered".
        let table = modulestab::new();
        let features = table.list_features("zsh/complete");
        assert!(features.is_empty());
        assert!(table.module_linked("zsh/complete"));
    }

    #[test]
    fn test_module_linked() {
        let _g = crate::test_util::global_state_lock();
        let table = modulestab::new();
        assert!(table.module_linked("zsh/complete"));
        assert!(table.module_linked("zsh/stat"));
        assert!(!table.module_linked("zsh/nonexistent"));
    }

    #[test]
    fn test_printmodulenode() {
        let _g = crate::test_util::global_state_lock();
        let module = module::new("zsh/test");
        // Loaded module (MOD_LINKED set by `module::new`), no flags →
        // emit just the module name (c:240 nicezputs(modname)).
        let output = printmodulenode("zsh/test", &module, 0);
        assert_eq!(output, "zsh/test");
        // Under PRINTMOD_LIST the loaded branch emits `zmodload MOD`.
        let listed = printmodulenode("zsh/test", &module, PRINTMOD_LIST);
        assert_eq!(listed, "zmodload zsh/test");
    }

    // ===== Tests for the `addmathfunc` / `removemathfunc` /
    // `deletemathfunc` family ported in this session against the
    // MATHFUNCS Lazy<Mutex<Vec<mathfunc>>> global. Each test isolates
    // its names with a unique prefix so they don't collide if the
    // suite runs in parallel.

    fn mk_mf(name: &str, autoload: bool) -> mathfunc {
        mathfunc {
            next: None,
            name: name.to_string(),
            flags: 0,
            nfunc: None,
            sfunc: None,
            module: if autoload {
                Some("zsh/test".to_string())
            } else {
                None
            },
            minargs: 0,
            maxargs: 0,
            funcid: 0,
        }
    }

    #[test]
    fn addmathfunc_clash_returns_one_when_already_added() {
        let _g = crate::test_util::global_state_lock();
        // C addmathfunc returns 1 when an existing entry has the same
        // name AND is non-autoloadable (no module set). Verifies the
        // "already in table" branch at module.c:1322-1330.
        let f1 = mk_mf("zshrs_test_clash_a", false);
        let f2 = mk_mf("zshrs_test_clash_a", false);
        assert_eq!(addmathfunc(f1), 0);
        assert_eq!(addmathfunc(f2), 1, "second add should clash");
        removemathfunc("zshrs_test_clash_a");
    }

    #[test]
    fn addmathfunc_autoload_replace_succeeds() {
        let _g = crate::test_util::global_state_lock();
        // When existing entry IS autoloadable (module.is_some, no
        // MFF_USERFUNC), C removes-then-replaces. The new entry should
        // land at index 0 (prepend) per c:1334-1335.
        let auto = mk_mf("zshrs_test_replace", true);
        let real = mk_mf("zshrs_test_replace", false);
        assert_eq!(addmathfunc(auto), 0);
        assert_eq!(
            addmathfunc(real),
            0,
            "autoloadable entry must be replaceable"
        );
        let tab = MATHFUNCS.lock().unwrap();
        let entry = tab.iter().find(|m| m.name == "zshrs_test_replace").unwrap();
        assert!(
            entry.module.is_none(),
            "after replace, module should be None"
        );
        drop(tab);
        removemathfunc("zshrs_test_replace");
    }

    #[test]
    fn removemathfunc_returns_unit_and_drops() {
        let _g = crate::test_util::global_state_lock();
        let f = mk_mf("zshrs_test_remove", false);
        assert_eq!(addmathfunc(f), 0);
        assert!(MATHFUNCS
            .lock()
            .unwrap()
            .iter()
            .any(|m| m.name == "zshrs_test_remove"));
        removemathfunc("zshrs_test_remove");
        assert!(!MATHFUNCS
            .lock()
            .unwrap()
            .iter()
            .any(|m| m.name == "zshrs_test_remove"));
    }

    #[test]
    fn deletemathfunc_returns_minus_one_on_miss() {
        let _g = crate::test_util::global_state_lock();
        // C: returns -1 when no matching entry; verifies the c:1361 branch.
        let probe = mk_mf("zshrs_test_never_added_xyz", false);
        assert_eq!(deletemathfunc(&probe), -1);
    }

    #[test]
    fn deletemathfunc_clears_added_flag_for_userfunc() {
        let _g = crate::test_util::global_state_lock();
        // For non-module entries (`!f->module`), C clears the MFF_ADDED
        // flag instead of dropping the node (c:1357). Tests by adding
        // a user-defined mathfunc, flipping MFF_ADDED on, then deleting.
        let mut f = mk_mf("zshrs_test_clear_flag", false);
        f.flags = MFF_ADDED;
        assert_eq!(
            addmathfunc(f),
            1,
            "MFF_ADDED set → addmathfunc clashes at c:1318"
        );
        // Now seed it manually with module=None and MFF_ADDED so deletemathfunc
        // exercises the clear-flag branch.
        MATHFUNCS
            .lock()
            .unwrap()
            .insert(0, mk_mf("zshrs_test_clear_flag2", false));
        let mut f2 = mk_mf("zshrs_test_clear_flag2", false);
        f2.flags = MFF_ADDED;
        // f2 is the lookup probe; by name it matches the seeded entry.
        assert_eq!(deletemathfunc(&f2), 0);
        let tab = MATHFUNCS.lock().unwrap();
        let entry = tab.iter().find(|m| m.name == "zshrs_test_clear_flag2");
        // Entry stays in the table (module was None) but MFF_ADDED cleared.
        if let Some(e) = entry {
            assert_eq!(e.flags & MFF_ADDED, 0);
        }
        drop(tab);
        removemathfunc("zshrs_test_clear_flag2");
    }

    // ===== Tests for `addconddef` / `deleteconddef` against CONDTAB.

    fn mk_cd(name: &str, infix: bool, autoload: bool) -> conddef {
        conddef {
            next: None,
            name: name.to_string(),
            flags: if infix {
                CONDF_INFIX
            } else {
                0
            },
            handler: None,
            min: 0,
            max: 0,
            condid: 0,
            module: if autoload {
                Some("zsh/cond".to_string())
            } else {
                None
            },
        }
    }

    #[test]
    fn addconddef_clash_returns_one() {
        let _g = crate::test_util::global_state_lock();
        // C addconddef: clash when existing has same name+infix AND is
        // not autoloadable, OR is already added (CONDF_ADDED flag).
        let c1 = mk_cd("zshrs_test_cond_clash", false, false);
        let c2 = mk_cd("zshrs_test_cond_clash", false, false);
        assert_eq!(addconddef(c1), 0);
        assert_eq!(addconddef(c2), 1);
        let probe = mk_cd("zshrs_test_cond_clash", false, false);
        assert_eq!(deleteconddef(&probe), 0);
    }

    #[test]
    fn deleteconddef_returns_minus_one_on_miss() {
        let _g = crate::test_util::global_state_lock();
        let probe = mk_cd("zshrs_test_cond_never_added", false, false);
        assert_eq!(deleteconddef(&probe), -1);
    }

    #[test]
    fn addconddef_distinguishes_infix_from_prefix() {
        let _g = crate::test_util::global_state_lock();
        // CONDF_INFIX is part of the clash key — a prefix-form `-z` and
        // an infix-form `==` share neither name nor flag, so adding both
        // names with different infix bits should both succeed.
        let prefix = mk_cd("zshrs_test_cond_dual", false, false);
        let infix = mk_cd("zshrs_test_cond_dual", true, false);
        assert_eq!(addconddef(prefix), 0);
        assert_eq!(
            addconddef(infix),
            0,
            "infix variant must not clash with prefix variant"
        );
        // Cleanup both
        let _ = deleteconddef(&mk_cd("zshrs_test_cond_dual", false, false));
        let _ = deleteconddef(&mk_cd("zshrs_test_cond_dual", true, false));
    }

    // ===== Tests for `setconddefs` / `setmathfuncs` bulk dispatch.

    #[test]
    fn setconddefs_bulk_add_then_bulk_delete_via_e_array() {
        let _g = crate::test_util::global_state_lock();
        // C setconddefs: walks (c, e) pairs; e[i]!=0 → addconddef path,
        // e[i]==0 → deleteconddef path. Tests the round trip.
        let mut entries = vec![
            mk_cd("zshrs_test_bulk_a", false, false),
            mk_cd("zshrs_test_bulk_b", false, false),
        ];
        let add_selectors = [1, 1];
        assert_eq!(setconddefs("test", &mut entries, Some(&add_selectors)), 0);
        // Both should now have CONDF_ADDED set per c:773.
        assert_ne!(entries[0].flags & CONDF_ADDED, 0);
        assert_ne!(entries[1].flags & CONDF_ADDED, 0);
        // Now delete both via e=[0,0].
        let del_selectors = [0, 0];
        assert_eq!(setconddefs("test", &mut entries, Some(&del_selectors)), 0);
        assert_eq!(entries[0].flags & CONDF_ADDED, 0);
        assert_eq!(entries[1].flags & CONDF_ADDED, 0);
    }

    // ===== Tests for `addbuiltin` / `addbuiltins` against canonical builtintab.

    fn mk_b(nam: &str) -> builtin {
        builtin {
            node: hashnode {
                next: None,
                nam: nam.to_string(),
                flags: 0,
            },
            handlerfunc: None,
            minargs: 0,
            maxargs: 0,
            funcid: 0,
            optstr: None,
            defopts: None,
        }
    }

    #[test]
    fn addbuiltin_clash_against_existing_builtintab_entry() {
        let _g = crate::test_util::global_state_lock();
        // C addbuiltin: returns 1 when builtintab already has an entry
        // for the same name with BINF_ADDED set. The canonical Rust
        // builtintab is populated at startup via createbuiltintable;
        // probing a real builtin like "echo" should clash if BINF_ADDED.
        let _ = createbuiltintable();
        let mut b = mk_b("echo");
        let r = addbuiltin(&mut b);
        // BINF_ADDED gets set on b when no clash. If echo was BINF_ADDED in
        // the static table, r==1; otherwise r==0 and b.flags now has BINF_ADDED.
        assert!(r == 0 || r == 1);
        if r == 0 {
            assert_ne!(b.node.flags & BINF_ADDED as i32, 0);
        }
    }

    #[test]
    fn addbuiltins_skips_already_added_entries() {
        let _g = crate::test_util::global_state_lock();
        // C addbuiltins (c:553): `if (b->node.flags & BINF_ADDED) continue`.
        // Pre-marking BINF_ADDED should skip both entries; ret stays 0.
        let mut b1 = mk_b("zshrs_test_already_added_1");
        b1.node.flags = BINF_ADDED as i32;
        let mut b2 = mk_b("zshrs_test_already_added_2");
        b2.node.flags = BINF_ADDED as i32;
        let mut binl = vec![b1, b2];
        assert_eq!(addbuiltins("test", &mut binl), 0);
    }

    // ===== Tests for `addwrapper` / `deletewrapper` against WRAPPERS.

    fn mk_w() -> funcwrap {
        funcwrap {
            next: None,
            flags: 0,
            handler: Some(|_prog, _w, _name| 0),
            module: None,
        }
    }

    #[test]
    fn addwrapper_then_deletewrapper_round_trip() {
        let _g = crate::test_util::global_state_lock();
        let w = mk_w();
        assert_eq!(addwrapper("zsh/test", w), 0);
        let probe = mk_w();
        let r = deletewrapper("zsh/test", &probe);
        // fn_addr_eq may match (most common case) or miss across codegen
        // units. Either outcome is documented behavior; verify it doesn't
        // panic and returns 0/1 cleanly.
        assert!(r == 0 || r == 1);
    }

    #[test]
    fn deletewrapper_returns_one_when_not_found() {
        let _g = crate::test_util::global_state_lock();
        // Empty WRAPPERS means any probe misses. Take a snapshot of the
        // current state, drain WRAPPERS, run the test, restore.
        let snapshot: Vec<_> = WRAPPERS.lock().unwrap().drain(..).collect();
        let probe = mk_w();
        assert_eq!(deletewrapper("zsh/test", &probe), 1);
        WRAPPERS.lock().unwrap().extend(snapshot);
    }

    // C-faithful hookdef tests. The system under test is:
    //   - `hooktab` (file-static linked-list head, port of c:843)
    //   - `gethookdef` / `addhookdef` / `addhookdefs` / `deletehookdef` /
    //     `deletehookdefs` / `addhookdeffunc` / `addhookfunc` /
    //     `deletehookdeffunc` / `deletehookfunc` / `runhookdef` —
    //     C-identical signatures over real `Hookfn` fn pointers.
    //
    // Each test holds `global_state_lock` and snapshots the chain at
    // start so any incidental registrations from other state leak don't
    // affect outcomes.

    // Real Rust ported matching the `Hookfn` shape. Used as test handlers
    // that bump a per-test atomic counter when invoked, proving
    // `runhookdef` actually dispatches the registered fn pointers.
    static H1_CALLS: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(0);
    static H2_CALLS: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(0);
    static H1_RETVAL: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(0);

    fn h1(_h: *mut hookdef, _d: *mut std::ffi::c_void) -> i32 {
        H1_CALLS.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
        H1_RETVAL.load(std::sync::atomic::Ordering::SeqCst)
    }
    fn h2(_h: *mut hookdef, _d: *mut std::ffi::c_void) -> i32 {
        H2_CALLS.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
        0
    }

    // Allocate a fresh hookdef on the heap and leak its Box so that the
    // returned `*mut hookdef` has program-lifetime — matching C's
    // static-storage hookdef nodes (zshhooks[] etc.). The test then
    // takes responsibility for splicing it out via deletehookdef.
    fn leak_hookdef(name: &str, flags: i32) -> *mut hookdef {
        Box::into_raw(Box::new(hookdef {
            next: std::ptr::null_mut(),
            name: name.to_string(),
            def: None,
            flags,
            funcs: std::ptr::null_mut(),
        }))
    }

    /// `gethookdef` returns null when no hookdef with that name is in
    /// `hooktab`, and the registered pointer once `addhookdef` runs.
    #[test]
    fn gethookdef_returns_null_then_registered_ptr() {
        let _g = crate::test_util::global_state_lock();
        // Unique name to avoid colliding with other tests' registrations.
        let h = leak_hookdef("zshrs_test_get_hook", HOOKF_ALL);
        unsafe {
            assert!(gethookdef(&(*h).name).is_null());
        }
        assert_eq!(addhookdef(h), 0);
        unsafe {
            assert_eq!(gethookdef(&(*h).name), h);
        }
        // Cleanup so the chain doesn't leak into other tests.
        assert_eq!(deletehookdef(h), 0);
        unsafe {
            drop(Box::from_raw(h));
        }
    }

    /// `addhookdef` rejects a name already present in `hooktab`
    /// (port of c:866-867: `if (gethookdef(h->name)) return 1`).
    #[test]
    fn addhookdef_rejects_duplicate_name() {
        let _g = crate::test_util::global_state_lock();
        let h1 = leak_hookdef("zshrs_test_dup_hook", HOOKF_ALL);
        let h2 = leak_hookdef("zshrs_test_dup_hook", HOOKF_ALL);
        assert_eq!(addhookdef(h1), 0);
        assert_eq!(addhookdef(h2), 1, "duplicate name must return 1");
        // Cleanup.
        assert_eq!(deletehookdef(h1), 0);
        unsafe {
            drop(Box::from_raw(h1));
            drop(Box::from_raw(h2));
        }
    }

    /// `deletehookdef` returns 1 when the hookdef isn't in the chain
    /// (port of c:909-910: `if (!p) return 1`) and 0 after add.
    #[test]
    fn deletehookdef_returns_one_on_miss_zero_on_hit() {
        let _g = crate::test_util::global_state_lock();
        let h = leak_hookdef("zshrs_test_del_hook", HOOKF_ALL);
        assert_eq!(deletehookdef(h), 1, "not in chain → 1");
        assert_eq!(addhookdef(h), 0);
        assert_eq!(deletehookdef(h), 0, "spliced out → 0");
        assert_eq!(deletehookdef(h), 1, "second delete misses → 1");
        unsafe {
            drop(Box::from_raw(h));
        }
    }

    /// `runhookdef` dispatches every registered Hookfn under `HOOKF_ALL`
    /// (port of c:996-1004) — the test handlers' counters bump on every
    /// fire, and the first non-zero return short-circuits.
    #[test]
    fn runhookdef_dispatches_all_under_hookf_all_short_circuits_on_nonzero() {
        let _g = crate::test_util::global_state_lock();
        H1_CALLS.store(0, std::sync::atomic::Ordering::SeqCst);
        H2_CALLS.store(0, std::sync::atomic::Ordering::SeqCst);
        H1_RETVAL.store(0, std::sync::atomic::Ordering::SeqCst);

        let h = leak_hookdef("zshrs_test_runall", HOOKF_ALL);
        assert_eq!(addhookdef(h), 0);
        assert_eq!(addhookdeffunc(h, h1), 0);
        assert_eq!(addhookdeffunc(h, h2), 0);

        // Both fire → r1=0, r2=0 → final return 0.
        assert_eq!(runhookdef(h, std::ptr::null_mut()), 0);
        assert_eq!(H1_CALLS.load(std::sync::atomic::Ordering::SeqCst), 1);
        assert_eq!(H2_CALLS.load(std::sync::atomic::Ordering::SeqCst), 1);

        // Make h1 return 7 → runhookdef should return 7 without calling h2.
        H1_CALLS.store(0, std::sync::atomic::Ordering::SeqCst);
        H2_CALLS.store(0, std::sync::atomic::Ordering::SeqCst);
        H1_RETVAL.store(7, std::sync::atomic::Ordering::SeqCst);
        assert_eq!(runhookdef(h, std::ptr::null_mut()), 7);
        assert_eq!(H1_CALLS.load(std::sync::atomic::Ordering::SeqCst), 1);
        assert_eq!(
            H2_CALLS.load(std::sync::atomic::Ordering::SeqCst),
            0,
            "h2 must not fire after h1 returns nonzero"
        );

        // Cleanup.
        assert_eq!(deletehookdef(h), 0);
        unsafe {
            drop(Box::from_raw(h));
        }
    }

    /// `runhookdef` calls only the LAST registered Hookfn when
    /// `HOOKF_ALL` is clear (port of c:1006).
    #[test]
    fn runhookdef_calls_only_last_when_hookf_all_clear() {
        let _g = crate::test_util::global_state_lock();
        H1_CALLS.store(0, std::sync::atomic::Ordering::SeqCst);
        H2_CALLS.store(0, std::sync::atomic::Ordering::SeqCst);
        H1_RETVAL.store(0, std::sync::atomic::Ordering::SeqCst);

        let h = leak_hookdef("zshrs_test_runlast", 0); // HOOKF_ALL clear
        assert_eq!(addhookdef(h), 0);
        assert_eq!(addhookdeffunc(h, h1), 0);
        assert_eq!(addhookdeffunc(h, h2), 0);

        runhookdef(h, std::ptr::null_mut());
        assert_eq!(
            H1_CALLS.load(std::sync::atomic::Ordering::SeqCst),
            0,
            "h1 must not fire when HOOKF_ALL is clear"
        );
        assert_eq!(
            H2_CALLS.load(std::sync::atomic::Ordering::SeqCst),
            1,
            "only the last-registered handler fires"
        );

        assert_eq!(deletehookdef(h), 0);
        unsafe {
            drop(Box::from_raw(h));
        }
    }

    /// `deletehookdeffunc` removes a single Hookfn from the chain
    /// (port of c:961-973). Pins the closure-shadow regression at the
    /// new free-fn surface.
    #[test]
    fn deletehookdeffunc_removes_only_target_hookfn() {
        let _g = crate::test_util::global_state_lock();
        H1_CALLS.store(0, std::sync::atomic::Ordering::SeqCst);
        H2_CALLS.store(0, std::sync::atomic::Ordering::SeqCst);
        H1_RETVAL.store(0, std::sync::atomic::Ordering::SeqCst);

        let h = leak_hookdef("zshrs_test_del_fn", HOOKF_ALL);
        assert_eq!(addhookdef(h), 0);
        addhookdeffunc(h, h1);
        addhookdeffunc(h, h2);
        // Remove only h1 — h2 must remain and fire.
        assert_eq!(deletehookdeffunc(h, h1), 0);
        // Second remove of h1 returns 1 (miss).
        assert_eq!(deletehookdeffunc(h, h1), 1);
        runhookdef(h, std::ptr::null_mut());
        assert_eq!(H1_CALLS.load(std::sync::atomic::Ordering::SeqCst), 0);
        assert_eq!(H2_CALLS.load(std::sync::atomic::Ordering::SeqCst), 1);

        assert_eq!(deletehookdef(h), 0);
        unsafe {
            drop(Box::from_raw(h));
        }
    }

    /// `addhookfunc` / `deletehookfunc` return 1 when no hookdef with
    /// that name is registered (port of c:953, c:982).
    #[test]
    fn addhookfunc_and_deletehookfunc_return_one_when_no_hookdef() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(addhookfunc("zshrs_test_no_such_hook", h1), 1);
        assert_eq!(deletehookfunc("zshrs_test_no_such_hook", h1), 1);
    }

    /// `addhookdefs(NULL, h_array, size)` registers contiguous hookdef
    /// nodes from an array (port of c:883-895). Each entry must be
    /// findable via `gethookdef` after the call.
    #[test]
    fn addhookdefs_registers_contiguous_array() {
        let _g = crate::test_util::global_state_lock();
        let arr: Box<[hookdef; 2]> = Box::new([
            hookdef {
                next: std::ptr::null_mut(),
                name: "zshrs_test_arr_0".into(),
                def: None,
                flags: HOOKF_ALL,
                funcs: std::ptr::null_mut(),
            },
            hookdef {
                next: std::ptr::null_mut(),
                name: "zshrs_test_arr_1".into(),
                def: None,
                flags: HOOKF_ALL,
                funcs: std::ptr::null_mut(),
            },
        ]);
        let base: *mut hookdef =
            Box::into_raw(arr) as *mut hookdef;
        assert_eq!(addhookdefs(std::ptr::null(), base, 2), 0);
        assert_eq!(gethookdef("zshrs_test_arr_0"), base);
        unsafe {
            assert_eq!(gethookdef("zshrs_test_arr_1"), base.add(1));
        }
        // Cleanup. Splice out then re-take ownership of the boxed array.
        unsafe {
            assert_eq!(deletehookdef(base), 0);
            assert_eq!(deletehookdef(base.add(1)), 0);
            drop(Box::from_raw(
                base as *mut [hookdef; 2],
            ));
        }
    }
}

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

    /// c:2173 — `modname_ok` accepts shell identifier names possibly
    /// joined by `/` (zsh modules are namespaced like `zsh/datetime`).
    /// Plain alphanumeric names with `/` separators MUST pass.
    /// A regression rejecting valid module names would break every
    /// `zmodload zsh/datetime` invocation.
    #[test]
    fn modname_ok_accepts_canonical_zsh_module_paths() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(modname_ok("zsh"), 1);
        assert_eq!(modname_ok("zsh/datetime"), 1);
        assert_eq!(modname_ok("zsh/zle"), 1);
        assert_eq!(modname_ok("foo_bar"), 1);
        assert_eq!(modname_ok("foo123"), 1);
    }

    /// c:2179 — non-identifier chars (excluding `/`) MUST cause
    /// rejection. A regression accepting them would let modules
    /// install with names that no later `zmodload -u` could remove.
    #[test]
    fn modname_ok_rejects_special_chars() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(modname_ok("zsh space"), 0);
        assert_eq!(modname_ok("zsh-bad"), 0, "hyphen is not IIDENT");
        assert_eq!(modname_ok("zsh.foo"), 0, "dot is not IIDENT");
        assert_eq!(modname_ok("$foo"), 0);
    }

    /// c:2177 — `if (!*p) return 1` runs at the START of the loop;
    /// empty input therefore returns 1. Pin this behaviour so callers
    /// know the empty-string case maps to "trivially OK" not "error".
    #[test]
    fn modname_ok_treats_empty_as_trivially_ok() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(modname_ok(""), 1);
    }

    /// `Src/module.c:464-478` — `del_autobin` returns 2 for "no such
    /// builtin" (unless FEAT_IGNORE), 3 for "registered builtin —
    /// can't unload" (unless FEAT_IGNORE), 0 for success.
    #[test]
    fn del_autobin_unknown_name_returns_2_or_zero_per_feat_ignore() {
        let _g = crate::test_util::global_state_lock();
        let mut t = modulestab::new();
        // unknown name + no FEAT_IGNORE → 2
        assert_eq!(t.del_autobin("definitely_not_a_builtin", 0), 2);
        // unknown name + FEAT_IGNORE → 0
        assert_eq!(t.del_autobin("definitely_not_a_builtin", FEAT_IGNORE), 0);
    }

    /// `Src/module.c:464-478` — known static-linked builtin (e.g. "echo")
    /// is in createbuiltintable(), counts as BINF_ADDED → return 3
    /// unless FEAT_IGNORE.
    #[test]
    fn del_autobin_registered_builtin_returns_3_or_zero_per_feat_ignore() {
        let _g = crate::test_util::global_state_lock();
        let mut t = modulestab::new();
        // "echo" is a static-linked builtin → can't unload → 3
        assert_eq!(t.del_autobin("echo", 0), 3);
        // With FEAT_IGNORE → 0
        assert_eq!(t.del_autobin("echo", FEAT_IGNORE), 0);
    }

    /// `Src/module.c:464-478` — name that was added via `add_autobin`
    /// (i.e. in autoload_builtins) but NOT in builtintab → success
    /// path → return 0 + removes from autoload ledger.
    #[test]
    fn del_autobin_autoload_only_entry_removed() {
        let _g = crate::test_util::global_state_lock();
        let mut t = modulestab::new();
        // Seed an autoload entry not in the static builtintab.
        t.autoload_builtins
            .insert("zshrs_test_autobin_x".to_string(), "mymod".to_string());
        assert_eq!(t.del_autobin("zshrs_test_autobin_x", 0), 0);
        assert!(
            !t.autoload_builtins.contains_key("zshrs_test_autobin_x"),
            "successful del must remove ledger entry"
        );
        // Second call → now "no such" → 2.
        assert_eq!(t.del_autobin("zshrs_test_autobin_x", 0), 2);
        assert_eq!(t.del_autobin("zshrs_test_autobin_x", FEAT_IGNORE), 0);
    }

    /// `Src/module.c:819-835` — `del_autocond` parallel contract: 2
    /// for "no such", 0 for autoload-entry-removed.
    #[test]
    fn del_autocond_autoload_entry_removed_or_not_found() {
        let _g = crate::test_util::global_state_lock();
        let mut t = modulestab::new();
        // Not present → 2 / 0 per FEAT_IGNORE.
        assert_eq!(t.del_autocond("zshrs_test_cond_x", 0), 2);
        assert_eq!(t.del_autocond("zshrs_test_cond_x", FEAT_IGNORE), 0);
        // Seed and delete.
        t.autoload_conditions
            .insert("zshrs_test_cond_x".to_string(), "mymod".to_string());
        assert_eq!(t.del_autocond("zshrs_test_cond_x", 0), 0);
        assert!(!t.autoload_conditions.contains_key("zshrs_test_cond_x"));
    }

    /// `Src/module.c:1240-1255` — `del_autoparam` parallel contract.
    /// 2 for "no such", 3 for "param exists without PM_AUTOLOAD —
    /// can't unload", 0 for success.
    #[test]
    fn del_autoparam_unknown_name_returns_2() {
        let _g = crate::test_util::global_state_lock();
        let mut t = modulestab::new();
        assert_eq!(t.del_autoparam("zshrs_test_param_x_unknown", 0), 2);
        assert_eq!(
            t.del_autoparam("zshrs_test_param_x_unknown", FEAT_IGNORE),
            0
        );
    }

    // ─── zsh-corpus pins for module table ───────────────────────────

    /// `register_module` returns true on first registration.
    #[test]
    fn module_corpus_register_new_returns_true() {
        let _g = crate::test_util::global_state_lock();
        let mut t = newmoduletable();
        assert!(register_module(&mut t, "myfresh.module"));
    }

    /// `register_module` returns false on duplicate registration.
    #[test]
    fn module_corpus_register_duplicate_returns_false() {
        let _g = crate::test_util::global_state_lock();
        let mut t = newmoduletable();
        assert!(register_module(&mut t, "dup.module"));
        assert!(!register_module(&mut t, "dup.module"),
            "second registration of same name = false");
    }

    /// New modulestab is pre-seeded with built-in modules.
    /// Pin: pre-seed count is positive and stable.
    #[test]
    fn module_corpus_new_table_has_builtin_modules() {
        let _g = crate::test_util::global_state_lock();
        let t = newmoduletable();
        assert!(t.modules.len() >= 1, "fresh modulestab has built-ins, got {}", t.modules.len());
    }

    /// `register_module` with empty name does not panic.
    #[test]
    fn module_corpus_register_empty_name_does_not_panic() {
        let _g = crate::test_util::global_state_lock();
        let mut t = newmoduletable();
        let _ = register_module(&mut t, "");
    }

    /// Default callback `setup_` returns 0.
    #[test]
    fn module_corpus_setup_callback_default_returns_zero() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(setup_(std::ptr::null()), 0);
    }

    /// Default `boot_` returns 0.
    #[test]
    fn module_corpus_boot_callback_default_returns_zero() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(boot_(std::ptr::null()), 0);
    }

    /// Default `cleanup_` returns 0.
    #[test]
    fn module_corpus_cleanup_callback_default_returns_zero() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(cleanup_(std::ptr::null()), 0);
    }

    /// Default `finish_` returns 0.
    #[test]
    fn module_corpus_finish_callback_default_returns_zero() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(finish_(std::ptr::null()), 0);
    }
}