zshrs 0.11.18

//! Mathematical expression evaluation for zshrs
//!
//! Direct port from zsh/Src/math.c
//!
//! Supports:
//! - Integer and floating point arithmetic
//! - All C operators (+, -, *, /, %, <<, >>, &, |, ^, etc.)
//! - Zsh ** power operator
//! - Comparison operators (<, >, <=, >=, ==, !=)
//! - Logical operators (&&, ||, !)
//! - Ternary operator (? :)
//! - Assignment operators (=, +=, -=, *=, /=, etc.)
//! - Pre/post increment/decrement (++, --)
//! - Base conversion (`16#FF`, `2#1010`, `[16]FF`)
//! - Special values (Inf, NaN)
//! - Variable references and assignment

use std::cell::{Cell, RefCell};
use std::collections::HashMap;

use crate::ported::options::opt_state_set;
use crate::ported::params::{convbase, getsparam, unsetparam};
use crate::ported::utils::zerr;
/// Re-export of `mnumber` (defined in zsh_h.rs as the Src/zsh.h:95 port).
pub use crate::ported::zsh_h::{Nularg, MN_FLOAT, MN_INTEGER, MN_UNSET, mnumber};
use crate::zsh_h::{PM_EFLOAT, PM_FFLOAT, PM_INTEGER};

/// Re-export of `MN_FLOAT` (defined in zsh_h.rs as the Src/zsh.h:104 port).
/// Re-export of `MN_INTEGER` (defined in zsh_h.rs as the Src/zsh.h:103 port).
/// Re-export of `MN_UNSET` (defined in zsh_h.rs as the Src/zsh.h:105 port).

/// Port of `struct mathvalue` from `Src/math.c`:
///
/// ```c
/// struct mathvalue {
///     char *lval;     /* lvalue string for variable write-back  */
///     Value pval;     /* resolved variable handle (or NULL)     */
///     mnumber val;    /* current numeric value                  */
/// };
/// ```
#[derive(Clone)]
pub(crate) struct mathvalue {
    pub val: mnumber,
    pub lval: Option<String>,
    /// `Value pval` slot from the C source. zsh uses it to cache the
    /// resolved parameter handle so write-back doesn't re-parse the
    /// `lval` string. Rust port leaves this as `()` for now — the
    /// resolved variable lives in `crate::ported::exec::ShellExecutor`'s
    /// `variables` map, looked up by `lval` on each access.
    pub pval: (),
}

/// Operator associativity and type flags
const LR: u16 = 0x0000; // left-to-right
const RL: u16 = 0x0001; // right-to-left
const BOOL: u16 = 0x0002; // short-circuit boolean

const OP_A2: u16 = 0x0004; // 2 arguments
const OP_A2IR: u16 = 0x0008; // 2 args, return int
const OP_A2IO: u16 = 0x0010; // 2 args, must be int
const OP_E2: u16 = 0x0020; // 2 args with assignment
const OP_E2IO: u16 = 0x0040; // 2 args assign, must be int
const OP_OP: u16 = 0x0080; // expecting operator position
const OP_OPF: u16 = 0x0100; // followed by operator (after this, next is operator)

/// Math tokens — direct port of Src/math.c:109-162. C uses bare
/// `#define`s; the Rust port mirrors as `pub const` ints so
/// `static int mtok` (math.c:305) can be a plain `i32` and the
/// C precedence/type tables index by the literal numbers.
pub const M_INPAR: i32 = 0; // c:109  '('
pub const M_OUTPAR: i32 = 1; // c:110  ')'
pub const NOT: i32 = 2; // c:111  '!'
pub const COMP: i32 = 3; // c:112  '~'
pub const POSTPLUS: i32 = 4; // c:113  x++
pub const POSTMINUS: i32 = 5; // c:114  x--
pub const UPLUS: i32 = 6; // c:115  +x
pub const UMINUS: i32 = 7; // c:116  -x
pub const AND: i32 = 8; // c:117  &
pub const XOR: i32 = 9; // c:118  ^
pub const OR: i32 = 10; // c:119  |
pub const MUL: i32 = 11; // c:120  *
pub const DIV: i32 = 12; // c:121  /
pub const MOD: i32 = 13; // c:122  %
pub const PLUS: i32 = 14; // c:123  +
pub const MINUS: i32 = 15; // c:124  -
pub const SHLEFT: i32 = 16; // c:125  <<
pub const SHRIGHT: i32 = 17; // c:126  >>
pub const LES: i32 = 18; // c:127  <
pub const LEQ: i32 = 19; // c:128  <=
pub const GRE: i32 = 20; // c:129  >
pub const GEQ: i32 = 21; // c:130  >=
pub const DEQ: i32 = 22; // c:131  ==
pub const NEQ: i32 = 23; // c:132  !=
pub const DAND: i32 = 24; // c:133  &&
pub const DOR: i32 = 25; // c:134  ||
pub const DXOR: i32 = 26; // c:135  ^^
pub const QUEST: i32 = 27; // c:136  ? (ternary)
pub const COLON: i32 = 28; // c:137  :
pub const EQ: i32 = 29; // c:138  =
pub const PLUSEQ: i32 = 30; // c:139  +=
pub const MINUSEQ: i32 = 31; // c:140  -=
pub const MULEQ: i32 = 32; // c:141  *=
pub const DIVEQ: i32 = 33; // c:142  /=
pub const MODEQ: i32 = 34; // c:143  %=
pub const ANDEQ: i32 = 35; // c:144  &=
pub const XOREQ: i32 = 36; // c:145  ^=
pub const OREQ: i32 = 37; // c:146  |=
pub const SHLEFTEQ: i32 = 38; // c:147  <<=
pub const SHRIGHTEQ: i32 = 39; // c:148  >>=
pub const DANDEQ: i32 = 40; // c:149  &&=
pub const DOREQ: i32 = 41; // c:150  ||=
pub const DXOREQ: i32 = 42; // c:151  ^^=
pub const COMMA: i32 = 43; // c:152  ,
pub const EOI: i32 = 44; // c:153  end of input
pub const PREPLUS: i32 = 45; // c:154  ++x
pub const PREMINUS: i32 = 46; // c:155  --x
pub const NUM: i32 = 47; // c:156  number literal
pub const ID: i32 = 48; // c:157  identifier
pub const POWER: i32 = 49; // c:158  **
pub const CID: i32 = 50; // c:159  #identifier (char value)
pub const POWEREQ: i32 = 51; // c:160  **=
pub const FUNC: i32 = 52; // c:161  function call
/// Total token count — Src/math.c:162 `#define TOKCOUNT 53`. The
/// `c_prec`/`z_prec`/`type` arrays are sized by this.
pub const TOKCOUNT: usize = 53;

/// Port of `enum prec_type` from `Src/math.c`. `mathevall()` (line
/// 367) uses this to differentiate top-level expression evaluation
/// (`(())`, `$(())`) from function-argument evaluation
/// (`func(arg, arg, …)`) — argument-mode terminates parsing on
/// the first comma encountered at the top level.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[allow(non_camel_case_types)]
pub enum prec_type {
    MPREC_TOP,
    MPREC_ARG,
}

/// Port of `getmathparam(struct mathvalue *mptr)` from `Src/math.c:337`.
///
/// Look up a parameter by name from inside math context. zsh
/// auto-typesets a missing-but-referenced name (its mathparam
/// flag), but the Rust port keeps the variables map separate from
/// the param table so a miss returns `Integer(0)` and skips the
/// type-coercion. Indirect-string mode (`a="3+2"; $((a))`) is
/// handled by recursively evaluating the string value.
/// WARNING: param names don't match C — Rust=() vs C=(mptr)
pub(crate) fn getmathparam(name: &str) -> mnumber {
    // Strip array subscript if present
    let base_name = if let Some(bracket) = name.find('[') {
        &name[..bracket]
    } else {
        name
    };
    if let Some(v) = m_variables_get(base_name) {
        return v;
    }
    // c:Src/math.c:337 getmathparam — falls back to `getvalue(s)`
    // which parses the full subscript syntax (params.c:2180).
    // The Rust port previously required callers to seed
    // `with_string_variables` (a pre-populate pattern that
    // diverged from C). Read paramtab + array subscripts here
    // so matheval works without seeding.
    if let Some(bracket) = name.find('[') {
        let close = name.rfind(']').unwrap_or(name.len());
        let arr_name = &name[..bracket];
        let idx_str = &name[bracket + 1..close];
        // Recursively eval the index (so a[i+1], h[$k], etc work).
        // CRITICAL: save/restore evaluator state around the recursive
        // matheval — without this, the inner call's `push(idx_value)`
        // contaminates the OUTER expression's operand stack. Bug
        // manifested as `$((1 + arr[1]))` returning 10 (just arr[1])
        // because the outer NUM(1) got popped by the inner eval's
        // op() during `op(PLUS)` (which sees [NUM(1), ID(arr[1]),
        // NUM(1_from_idx_eval)] instead of [NUM(1), ID(arr[1])]).
        // C mathevall at math.c:367 does the same xyy* save/restore
        // around recursive entry.
        let saved = save_state();
        let idx_val = matheval(idx_str)
            .map(|n| {
                if n.type_ == MN_FLOAT {
                    n.d as i64
                } else {
                    n.l
                }
            })
            .unwrap_or(0);
        restore_state(saved);
        // Read paramtab directly: PM_ARRAY → u_arr indexed by 1-based pos.
        if let Ok(tab) = crate::ported::params::paramtab().read() {
            if let Some(pm) = tab.get(arr_name) {
                if let Some(arr) = &pm.u_arr {
                    let len = arr.len() as i64;
                    let pos = if idx_val < 0 {
                        len + idx_val
                    } else {
                        idx_val - 1
                    };
                    if pos >= 0 && (pos as usize) < arr.len() {
                        let raw = &arr[pos as usize];
                        if let Ok(n) = raw.parse::<i64>() {
                            return mnumber {
                                l: n,
                                d: 0.0,
                                type_: MN_INTEGER,
                            };
                        }
                        if let Ok(f) = raw.parse::<f64>() {
                            return mnumber {
                                l: 0,
                                d: f,
                                type_: MN_FLOAT,
                            };
                        }
                    }
                }
            }
        }
        // PM_HASHED via paramtab_hashed_storage.
        if let Ok(m) = crate::ported::params::paramtab_hashed_storage().lock() {
            if let Some(map) = m.get(arr_name) {
                if let Some(v) = map.get(idx_str) {
                    if let Ok(n) = v.parse::<i64>() {
                        return mnumber {
                            l: n,
                            d: 0.0,
                            type_: MN_INTEGER,
                        };
                    }
                    if let Ok(f) = v.parse::<f64>() {
                        return mnumber {
                            l: 0,
                            d: f,
                            type_: MN_FLOAT,
                        };
                    }
                }
            }
        }
        return mnumber {
            l: 0,
            d: 0.0,
            type_: MN_INTEGER,
        };
    }
    if let Some(raw) = getsparam(base_name) {
        if let Ok(n) = raw.parse::<i64>() {
            return mnumber {
                l: n,
                d: 0.0,
                type_: MN_INTEGER,
            };
        }
        if let Ok(f) = raw.parse::<f64>() {
            return mnumber {
                l: 0,
                d: f,
                type_: MN_FLOAT,
            };
        }
        // c:Src/math.c:337 getmathparam — falls back to recursively
        // evaluating the raw string as an arith expression. zsh: a
        // scalar holding `0xff` / `0b101` / `3+2` / `1e3` all evaluate
        // when used in arith context. Direct path through `matheval`
        // gives lexconstant + parser its full integer-base + float
        // handling.
        let saved = save_state();
        let inherited_strs = saved.string_variables.clone();
        new(&raw);
        m_variables_set(saved.variables.clone());
        let mut strs = inherited_strs;
        strs.remove(base_name);
        m_string_variables_set(strs);
        m_prec_set(saved.prec);
        m_c_precedences_set(saved.c_precedences);
        let result = mathevall();
        restore_state(saved);
        if let Ok(r) = result {
            return r;
        }
        // Non-numeric and non-evaluable string: fall through.
    }
    // Recursive eval: if the var holds a non-numeric string, evaluate
    // it AS an arith expression. zsh: `a="3+2"; $((a))` → 5. Bound
    // to one level of indirection — fresh evaluator each call so we
    // don't accidentally pollute s.variables.
    if let Some(raw) = m_string_variables_get(base_name) {
        // Save parent's eval state — `new(&raw)` resets thread_locals
        // for the sub-eval, which would otherwise clobber the parent.
        // Mirrors C `mathevall()` xyy* save/restore pattern (math.c:367).
        let saved = save_state();
        // Inherit caller's variables/string_variables/prec into the
        // sub-eval, with `base_name` removed from the indirect map to
        // prevent infinite recursion on `a="$a"`-style cycles.
        let inherited_vars = saved.variables.clone();
        let mut inherited_strs = saved.string_variables.clone();
        inherited_strs.remove(base_name);
        let inherited_prec = saved.prec;
        let inherited_c_prec = saved.c_precedences;

        new(&raw);
        m_variables_set(inherited_vars);
        m_string_variables_set(inherited_strs);
        m_prec_set(inherited_prec);
        m_c_precedences_set(inherited_c_prec);

        let result = mathevall();
        restore_state(saved);
        if let Ok(r) = result {
            return r;
        }
    }
    mnumber {
        l: 0,
        d: 0.0,
        type_: MN_INTEGER,
    }
}

/// Evaluate the expression
/// Port of `mathevall(char *s, enum prec_type prec_tp, char **ep)` from `Src/math.c:367`.
/// WARNING: param names don't match C — Rust=() vs C=(s, prec_tp, ep)
pub(crate) fn mathevall() -> Result<mnumber, String> {
    m_prec_set(if m_c_precedences() { &C_PREC } else { &Z_PREC });

    // c:Src/math.c:1485-1488 — `outputradix = outputunderscore = 0;`
    // at the top of each eval so a `[#16]` from a prior `$((…))`
    // doesn't leak into the next. The C body comment notes "maintain
    // outputradix and outputunderscore across levels of evaluation"
    // i.e. they DO persist across the levels-of-evaluation save/
    // restore that `new()` performs (which is why this lives at the
    // top of mathevall, NOT inside the save block).
    reset_output_format();

    // Skip leading whitespace and Nularg
    while let Some(c) = peek() {
        if c.is_whitespace() || c == '\u{a1}' {
            advance();
        } else {
            break;
        }
    }

    if m_pos() >= m_input_len() {
        return Ok(mnumber {
            l: 0,
            d: 0.0,
            type_: MN_INTEGER,
        });
    }

    mathparse(top_prec());

    if let Some(err) = m_error_take() {
        return Err(err);
    }

    // Check for trailing characters
    while let Some(c) = peek() {
        if c.is_whitespace() {
            advance();
        } else if c == ')' {
            // zsh's specific wording for the unmatched-close
            // case: `bad math expression: unexpected ')'`.
            return Err("bad math expression: unexpected ')'".to_string());
        } else {
            return Err(format!("illegal character: {}", c));
        }
    }

    if m_stack_is_empty() {
        return Ok(mnumber {
            l: 0,
            d: 0.0,
            type_: MN_INTEGER,
        });
    }

    let mv = m_stack_pop().unwrap();
    let result = if (mv.val.type_ == MN_UNSET) {
        if let Some(ref name) = mv.lval {
            getmathparam(name)
        } else {
            mnumber {
                l: 0,
                d: 0.0,
                type_: MN_INTEGER,
            }
        }
    } else {
        mv.val
    };

    Ok(result)
}

/// Port of `lexconstant()` from `Src/math.c:462`.
///
/// Lex a numeric constant — decimal/hex/binary/octal integer or
/// floating-point literal. Sets `m_yyval()` and returns
/// `NUM`. Recognises `0x`/`0b` prefixes, base-prefix
/// (`16#FF`), trailing-dot float, scientific notation, and zsh's
/// underscore digit-grouping. Mirrors C's `zstrtol_underscore()`
/// for greedy base parsing (consume valid digits only, leave the
/// rest as the next token).
pub(crate) fn lexconstant() -> i32 {
    let _start = m_pos();
    let mut is_neg = false;

    // Handle leading minus for unary context
    if peek() == Some('-') {
        is_neg = true;
        advance();
    }

    // Check for hex/binary/octal
    if peek() == Some('0') {
        advance();
        match peek().map(|c| c.to_ascii_lowercase()) {
            Some('x') => {
                // Hex: 0xFF
                advance();
                let hex_start = m_pos();
                while let Some(c) = peek() {
                    if c.is_ascii_hexdigit() || c == '_' {
                        advance();
                    } else {
                        break;
                    }
                }
                let hex_str: String = m_input_clone()[hex_start..m_pos()]
                    .chars()
                    .filter(|&c| c != '_')
                    .collect();
                let val = i64::from_str_radix(&hex_str, 16).unwrap_or(0);
                m_lastbase_set(16);
                m_yyval_set(if m_force_float() {
                    mnumber {
                        l: 0,
                        d: if is_neg { -(val as f64) } else { val as f64 },
                        type_: MN_FLOAT,
                    }
                } else {
                    mnumber {
                        l: if is_neg { -val } else { val },
                        d: 0.0,
                        type_: MN_INTEGER,
                    }
                });
                return NUM;
            }
            Some('b') => {
                // Binary: 0b1010
                advance();
                let bin_start = m_pos();
                while let Some(c) = peek() {
                    if c == '0' || c == '1' || c == '_' {
                        advance();
                    } else {
                        break;
                    }
                }
                let bin_str: String = m_input_clone()[bin_start..m_pos()]
                    .chars()
                    .filter(|&c| c != '_')
                    .collect();
                let val = i64::from_str_radix(&bin_str, 2).unwrap_or(0);
                m_lastbase_set(2);
                m_yyval_set(if m_force_float() {
                    mnumber {
                        l: 0,
                        d: if is_neg { -(val as f64) } else { val as f64 },
                        type_: MN_FLOAT,
                    }
                } else {
                    mnumber {
                        l: if is_neg { -val } else { val },
                        d: 0.0,
                        type_: MN_INTEGER,
                    }
                });
                return NUM;
            }
            Some('o') | Some('O') => {
                // zsh rejects `0o…` octal-prefix (Rust/Python form).
                // Only `0x` (hex), `0b` (binary), and bare-leading-0
                // (with `setopt octalzeroes`) are recognized. Emit
                // the same diagnostic zsh produces — set s.error
                // and return a stub Num so the caller's
                // error-propagation path picks up the failure.
                m_error_set(format!(
                    "bad math expression: operator expected at `{}'",
                    &m_input_clone()[m_pos()..]
                ));
                m_yyval_set(mnumber {
                    l: 0,
                    d: 0.0,
                    type_: MN_INTEGER,
                });
                return NUM;
            }
            _ => {
                // Could be octal or just 0
                if m_octal_zeroes() {
                    // Check if this looks like octal
                    let oct_start = m_pos();
                    let mut is_octal = true;
                    while let Some(c) = peek() {
                        if c.is_ascii_digit() || c == '_' {
                            if ('8'..='9').contains(&c) {
                                is_octal = false;
                            }
                            advance();
                        } else if c == '.' || c == 'e' || c == 'E' || c == '#' {
                            is_octal = false;
                            break;
                        } else {
                            break;
                        }
                    }
                    if is_octal && m_pos() > oct_start {
                        let oct_str: String = m_input_clone()[oct_start..m_pos()]
                            .chars()
                            .filter(|&c| c != '_')
                            .collect();
                        let val = i64::from_str_radix(&oct_str, 8).unwrap_or(0);
                        m_lastbase_set(8);
                        m_yyval_set(if m_force_float() {
                            mnumber {
                                l: 0,
                                d: if is_neg { -(val as f64) } else { val as f64 },
                                type_: MN_FLOAT,
                            }
                        } else {
                            mnumber {
                                l: if is_neg { -val } else { val },
                                d: 0.0,
                                type_: MN_INTEGER,
                            }
                        });
                        return NUM;
                    }
                    m_pos_set(oct_start);
                }
                // Put back the 0
                m_pos_sub(1);
            }
        }
    }

    // Parse decimal integer or float
    let num_start = m_pos();
    while let Some(c) = peek() {
        if is_digit(c) || c == '_' {
            advance();
        } else {
            break;
        }
    }

    // Check for float
    if peek() == Some('.') || peek() == Some('e') || peek() == Some('E') {
        // Float
        if peek() == Some('.') {
            advance();
            while let Some(c) = peek() {
                if is_digit(c) || c == '_' {
                    advance();
                } else {
                    break;
                }
            }
        }
        if peek() == Some('e') || peek() == Some('E') {
            advance();
            if peek() == Some('+') || peek() == Some('-') {
                advance();
            }
            while let Some(c) = peek() {
                if is_digit(c) || c == '_' {
                    advance();
                } else {
                    break;
                }
            }
        }
        let float_str: String = m_input_clone()[num_start..m_pos()]
            .chars()
            .filter(|&c| c != '_')
            .collect();
        let val: f64 = float_str.parse().unwrap_or(0.0);
        m_yyval_set(mnumber {
            l: 0,
            d: if is_neg { -val } else { val },
            type_: MN_FLOAT,
        });
        return NUM;
    }

    // Check for base#value syntax (e.g., 16#FF)
    if peek() == Some('#') {
        advance();
        let base_str: String = m_input_clone()[num_start..m_pos() - 1]
            .chars()
            .filter(|&c| c != '_')
            .collect();
        let base: u32 = base_str.parse().unwrap_or(10);
        // zsh: `1#X` errors with "invalid base (must be 2 to 36 inclusive)".
        // i64::from_str_radix panics on out-of-range base; reject early.
        if !(2..=36).contains(&base) {
            m_error_set(format!(
                "invalid base (must be 2 to 36 inclusive): {}",
                base
            ));
            m_yyval_set(mnumber {
                l: 0,
                d: 0.0,
                type_: MN_INTEGER,
            });
            return NUM;
        }
        m_lastbase_set(base as i32);

        // Mirror zsh's `zstrtol_underscore(ptr, &ptr, base, 1)`
        // semantics: consume ONLY chars valid for the base
        // (greedy), stopping at the first invalid digit.
        // Underscore-as-thousands-separator is allowed
        // mid-number. The remaining input becomes the next
        // token, which the parser will then trip on as
        // "operator expected at `<rest>'" via the regular
        // checkunary/parser path.
        //
        // Earlier version used Rust's `from_str_radix` which
        // is all-or-nothing — a single bad digit nuked the
        // entire literal. For `2#1011x` zsh consumes the
        // valid `1011` (= 11) and errors on the trailing `x`;
        // ours errored on the whole `1011x` as one chunk.
        // Same for `2#10112` (zsh: at `2`, ours: at `10112`).
        //
        // Empty-digit-sequence case (`10#`, `2#`) silently
        // yields 0, matching zsh's `zstrtol` returning 0 when
        // no valid digits follow.
        let mut val: i64 = 0;
        let base_i64 = base as i64;
        while let Some(c) = peek() {
            if c == '_' {
                advance();
                continue;
            }
            let digit_val: Option<u32> = if c.is_ascii_digit() {
                Some(c as u32 - '0' as u32)
            } else if c.is_ascii_alphabetic() {
                Some(c.to_ascii_lowercase() as u32 - 'a' as u32 + 10)
            } else {
                None
            };
            let Some(d) = digit_val else {
                break;
            };
            if d >= base {
                break;
            }
            val = val.saturating_mul(base_i64).saturating_add(d as i64);
            advance();
        }
        m_yyval_set(if m_force_float() {
            mnumber {
                l: 0,
                d: if is_neg { -(val as f64) } else { val as f64 },
                type_: MN_FLOAT,
            }
        } else {
            mnumber {
                l: if is_neg { -val } else { val },
                d: 0.0,
                type_: MN_INTEGER,
            }
        });
        return NUM;
    }

    // Plain integer
    let int_str: String = m_input_clone()[num_start..m_pos()]
        .chars()
        .filter(|&c| c != '_')
        .collect();
    let val: i64 = int_str.parse().unwrap_or(0);
    m_yyval_set(if m_force_float() {
        mnumber {
            l: 0,
            d: if is_neg { -(val as f64) } else { val as f64 },
            type_: MN_FLOAT,
        }
    } else {
        mnumber {
            l: if is_neg { -val } else { val },
            d: 0.0,
            type_: MN_INTEGER,
        }
    });
    NUM
}

// ===========================================================
// Remaining stubs from Src/math.c that don't yet have a faithful
// implementation in the migrated free-fn evaluator. The
// in-place implementations (mathevall, getmathparam, lexconstant,
// setmathvar, callmathfunc, checkunary) replaced their stubs;
// the names below correspond to C helpers the evaluator uses
// internally below — bodies wire to existing Rust idioms while
// preserving the C name + citation.
// ===========================================================

/// Port of `isinf(double x)` from Src/math.c:588 — IEEE +/-Infinity test.
/// Wraps Rust's `f64::is_infinite`.
/// WARNING: param names don't match C — Rust=() vs C=(x)
pub(crate) fn isinf(x: f64) -> bool {
    x.is_infinite()
}

/// Port of `isnan(double x)` from Src/math.c:608 — IEEE NaN test. C
/// implements it as `store(&x) != store(&x)` to defeat compiler
/// folding of the canonical `x != x` NaN test; we route through
/// `store` for parity, but Rust's `f64::is_nan` is the
/// correctness path.
/// WARNING: param names don't match C — Rust=() vs C=(x)
pub(crate) fn isnan(x: f64) -> bool {
    store(x) != store(x) || x.is_nan()
}

/// Port of `notzero(mnumber a)` from Src/math.c:1142 — error-on-zero check
/// used by `/` and `%` operators. Returns true when `a` is non-
/// zero (caller continues), false when zero (caller raises
/// "division by zero"). Float zero is treated as non-zero per
/// IEEE 754 (1/0.0 → Inf, not an error) — only integer zero
/// trips the check, matching math.c's `if (!a.u.l) zerr(…)`.
/// WARNING: param names don't match C — Rust=() vs C=(a)
pub(crate) fn notzero(a: mnumber) -> bool {
    if (a.type_ == MN_UNSET) {
        return false;
    }
    if (a.type_ == MN_INTEGER) {
        return a.l != 0;
    }
    true
}

// ============================================================
// Module-level math statics — direct port of Src/math.c globals.
//
// math.c declares each of these at file scope:
//   int noeval;                         // line 40
//   mnumber zero_mnumber;               // line 45
//   mnumber lastmathval;                // line 53
//   int lastbase;                       // line 58
//   static char *ptr;                   // line 60
//   static mnumber yyval;               // line 62
//   static char *yylval;                // line 63
//   static int mlevel = 0;              // line 67
//   static int unary = 1;               // line 71
//   static struct mathvalue *stack;     // (math.c body)
//   ... and a few derived from option flags (force_float, etc.).
//
// Rust port: thread_local!<Cell|RefCell<T>> per global. `mathevall`
// (math.c:367) saves these to its own locals (`xyyval`, `xyylval`,
// `xunary`, etc.) on entry and restores on exit so recursive math
// calls (function-arg eval, indirect string eval) don't clobber
// the outer evaluator's state.
//
// Cell for Copy types (i64/i32/usize/bool/mnumber/i32/&'static
// slice). RefCell for owned/non-Copy (String, Vec, HashMap, Option).
// ============================================================

thread_local! {
    /// `static char *ptr` — current input cursor. Owned String in Rust
    /// (vs C's caller-owned char*) so the thread_local isn't a borrow.
    static M_INPUT: RefCell<String> = const { RefCell::new(String::new()) };
    /// Byte offset into `M_INPUT` of the next char to lex.
    static M_POS: Cell<usize> = const { Cell::new(0) };
    /// Byte offset where the current token began (post-whitespace).
    /// Used to format zsh-style "at `<remaining>'" error pointers.
    static M_TOK_START: Cell<usize> = const { Cell::new(0) };
    /// `static mnumber yyval` (math.c:62) — value lexed by zzlex.
    static M_YYVAL: Cell<mnumber> = const { Cell::new(mnumber { l: 0, d: 0.0, type_: MN_INTEGER }) };
    /// `static char *yylval` (math.c:63) — identifier or function-call
    /// text lexed by zzlex (caller side reads via `M_YYLVAL.with(...)`).
    static M_YYLVAL: RefCell<String> = const { RefCell::new(String::new()) };
    /// `static struct mathvalue *stack` — operand stack for the
    /// shunting-yard evaluator. Mirrors C's heap-grown array.
    static M_STACK: RefCell<Vec<mathvalue >> = const { RefCell::new(Vec::new()) };
    /// `int mtok` — current token tag set by zzlex.
    static M_MTOK: Cell<i32> = const { Cell::new(EOI) };
    /// `static int unary` (math.c:71) — 1 when the parser is expecting
    /// an operand (so `+`/`-` mean unary plus/minus).
    static M_UNARY: Cell<bool> = const { Cell::new(true) };
    // nonzero means we are not evaluating, just parsing                    // c:37
    /// `int noeval` (math.c:40) — non-zero when in the parse-only side
    /// of `&&`/`||`/ternary; suppresses side-effects.
    static M_NOEVAL: Cell<i32> = const { Cell::new(0) };                    // c:40
    // last input base we used                                              // c:55
    /// `int lastbase` (math.c:58) — base of the last numeric literal
    /// (set by lexconstant, used by `$((…))` formatting).
    static M_LASTBASE: Cell<i32> = const { Cell::new(-1) };                 // c:58
    /// `int *prec` — active precedence table (Z_PREC or C_PREC).
    static M_PREC: Cell<&'static [u8; TOKCOUNT]> = const { Cell::new(&Z_PREC) };
    /// `setopt CPRECEDENCES` mirror.
    static M_C_PRECEDENCES: Cell<bool> = const { Cell::new(false) };
    /// `setopt FORCEFLOAT` mirror.
    static M_FORCE_FLOAT: Cell<bool> = const { Cell::new(false) };
    /// `setopt OCTALZEROES` mirror.
    static M_OCTAL_ZEROES: Cell<bool> = const { Cell::new(false) };
    /// In-memory params table (zshrs uses this instead of the C param
    /// table). Carries float/integer mnumber results.
    static M_VARIABLES: RefCell<HashMap<String, mnumber>> = RefCell::new(HashMap::new());
    /// Raw string values for variables whose contents aren't a plain
    /// number — recursively re-eval'd by `getmathparam` for
    /// `a="3+2"; $((a))` semantics.
    static M_STRING_VARIABLES: RefCell<HashMap<String, String>> = RefCell::new(HashMap::new());
    /// `$?` — last command exit status, used by the `?` token in
    /// unary position.
    static M_LASTVAL: Cell<i32> = const { Cell::new(0) };
    /// `$$` — current process ID, lexed for the `$` token.
    static M_PID: Cell<i64> = const { Cell::new(0) };
    /// Error message accumulator. zsh C uses `setjmp`/`longjmp`; the
    /// Rust port returns errors via this Option then `mathevall`
    /// surfaces it as `Result::Err`.
    static M_ERROR: RefCell<Option<String>> = const { RefCell::new(None) };
    /// `int outputradix` (math.c:580) — output base for the result.
    /// Set by `[#N]` (positive N, with `N#` prefix) or `[##N]`
    /// (negative N, bare digits). Read by subst.rs's `$((…))`
    /// formatter at math.c:4493-4498.
    static M_OUTPUTRADIX: Cell<i32> = const { Cell::new(0) };               // c:580
    /// `int outputunderscore` (math.c:583) — group every N digits with
    /// `_` for readable hex/decimal output. Set by `[#N_M]` /
    /// `[##N_M]` / `[#_M]`. Read alongside outputradix.
    static M_OUTPUTUNDERSCORE: Cell<i32> = const { Cell::new(0) };          // c:583
}

/// `outputradix` accessor for subst.rs's `$((…))` formatter.
/// Returns 0 if no `[#…]` directive was seen during the most
/// recent matheval. Caller is responsible for clearing via
/// `set_output_format(0, 0)` if it wants per-call state.
pub fn outputradix() -> i32 {
    M_OUTPUTRADIX.with(|c| c.get())
}

/// `outputunderscore` accessor — see [`outputradix`].
pub fn outputunderscore() -> i32 {
    M_OUTPUTUNDERSCORE.with(|c| c.get())
}

/// Reset the output-format state. Called by `mathevall` before
/// each evaluation so `[#16]` from a prior `$((…))` doesn't leak
/// into the next call.
pub fn reset_output_format() {
    M_OUTPUTRADIX.with(|c| c.set(0));
    M_OUTPUTUNDERSCORE.with(|c| c.set(0));
}

fn m_outputradix_set(v: i32) {
    M_OUTPUTRADIX.with(|c| c.set(v));
}

fn m_outputunderscore_set(v: i32) {
    M_OUTPUTUNDERSCORE.with(|c| c.set(v));
}

// ============================================================
// WARNING: NOT IN MATH.C — every `m_*` fn below is a Rust-only
// thread_local accessor. C dereferences the corresponding module
// global directly (`yyval.u.l`, `*ptr++`, etc.) without an
// fn-shaped wrapper. The wrappers exist solely because Rust's
// `thread_local!` requires `.with(|c| ...)` for any access, and
// scattering 600 such closures throughout the evaluator would be
// unreadable. Allowlisted in tests/data/fake_fn_allowlist.txt.
// ============================================================
// Accessor helpers — each thread_local reads/writes via these so the
// migration from `s.X` → free-fn-only access is mechanical.

#[inline]
fn m_input_clone() -> String {
    M_INPUT.with(|c| c.borrow().clone())
}
#[inline]
fn m_input_set(v: String) {
    M_INPUT.with(|c| *c.borrow_mut() = v)
}
#[inline]
fn m_input_len() -> usize {
    M_INPUT.with(|c| c.borrow().len())
}
#[inline]
fn m_input_byte(i: usize) -> u8 {
    M_INPUT.with(|c| c.borrow().as_bytes().get(i).copied().unwrap_or(0))
}
#[inline]
fn m_input_slice_from(start: usize) -> String {
    M_INPUT.with(|c| c.borrow()[start..].to_string())
}
#[inline]
fn m_input_slice(start: usize, end: usize) -> String {
    M_INPUT.with(|c| c.borrow()[start..end].to_string())
}

#[inline]
fn m_pos() -> usize {
    M_POS.with(|c| c.get())
}
#[inline]
fn m_pos_set(v: usize) {
    M_POS.with(|c| c.set(v))
}
#[inline]
fn m_pos_sub(n: usize) {
    M_POS.with(|c| c.set(c.get() - n))
}
#[inline]
fn m_pos_add(n: usize) {
    M_POS.with(|c| c.set(c.get() + n))
}

#[inline]
fn m_tok_start() -> usize {
    M_TOK_START.with(|c| c.get())
}
#[inline]
fn m_tok_start_set(v: usize) {
    M_TOK_START.with(|c| c.set(v))
}

#[inline]
fn m_yyval() -> mnumber {
    M_YYVAL.with(|c| c.get())
}
#[inline]
fn m_yyval_set(v: mnumber) {
    M_YYVAL.with(|c| c.set(v))
}

#[inline]
fn m_yylval_clone() -> String {
    M_YYLVAL.with(|c| c.borrow().clone())
}
#[inline]
fn m_yylval_set(v: String) {
    M_YYLVAL.with(|c| *c.borrow_mut() = v)
}

#[inline]
fn m_mtok() -> i32 {
    M_MTOK.with(|c| c.get())
}
#[inline]
fn m_mtok_set(t: i32) {
    M_MTOK.with(|c| c.set(t))
}

#[inline]
fn m_unary() -> bool {
    M_UNARY.with(|c| c.get())
}
#[inline]
fn m_unary_set(v: bool) {
    M_UNARY.with(|c| c.set(v))
}

/// Accessor for the math-evaluator `noeval` counter (`Src/math.c:40`
/// `int noeval`). C reads/writes the global directly — Rust ports
/// the global as a thread-local `M_NOEVAL` (so nested evaluators
/// stay isolated) and exposes the read via this `pub` accessor.
/// Used by exec.c's `execsave` / `execrestore` save/restore frame
/// (`Src/exec.c:6450,6486`) — the math state must round-trip across
/// nested sublist evaluation so a ternary-arm `noeval++/--` inside
/// one expression doesn't leak into outer evaluations.
#[inline]
pub fn m_noeval() -> i32 {
    M_NOEVAL.with(|c| c.get())
}
/// Setter paired with `m_noeval` — assigns the math-evaluator
/// `noeval` counter. C does plain `noeval = en->noeval;`; this is
/// the Rust thread-local equivalent.
#[inline]
pub fn m_noeval_set(v: i32) {
    M_NOEVAL.with(|c| c.set(v))
}
#[inline]
fn m_noeval_inc() {
    M_NOEVAL.with(|c| c.set(c.get() + 1))
}
#[inline]
fn m_noeval_dec() {
    M_NOEVAL.with(|c| c.set(c.get() - 1))
}

#[inline]
fn m_lastbase_set(v: i32) {
    M_LASTBASE.with(|c| c.set(v))
}

/// Public getter for `lastbase` — used by `assignstrvalue` in
/// params.rs to inherit the input numeric base when a freshly
/// assigned integer parameter has none of its own.
pub fn lastbase() -> i32 {
    M_LASTBASE.with(|c| c.get())
}

/// Public setter for `lastbase` — used by the bytecode arith
/// compiler (extensions/arith_compiler.rs) to communicate the
/// source numeric base when a `N#NNN` or `0x..` literal is
/// consumed inside `(( … ))`. The canonical math.c port at
/// `Src/math.c::lexconstant` sets this internally; bypassing
/// the canonical lexer (as `arith_compiler` does) requires
/// poking the TLS slot directly so assignsparam's `pm.base ==
/// 0 ? lastbase()` inheritance path fires.
pub fn set_lastbase(base: i32) {
    m_lastbase_set(base)
}

#[inline]
fn m_prec() -> &'static [u8; TOKCOUNT] {
    M_PREC.with(|c| c.get())
}
#[inline]
fn m_prec_set(p: &'static [u8; TOKCOUNT]) {
    M_PREC.with(|c| c.set(p))
}

#[inline]
fn m_c_precedences() -> bool {
    M_C_PRECEDENCES.with(|c| c.get())
}
#[inline]
fn m_c_precedences_set(v: bool) {
    M_C_PRECEDENCES.with(|c| c.set(v))
}
#[inline]
fn m_force_float() -> bool {
    M_FORCE_FLOAT.with(|c| c.get())
}
#[inline]
fn m_force_float_set(v: bool) {
    M_FORCE_FLOAT.with(|c| c.set(v))
}
#[inline]
fn m_octal_zeroes() -> bool {
    M_OCTAL_ZEROES.with(|c| c.get())
}
#[inline]
fn m_octal_zeroes_set(v: bool) {
    M_OCTAL_ZEROES.with(|c| c.set(v))
}

#[inline]
fn m_lastval_set(v: i32) {
    M_LASTVAL.with(|c| c.set(v))
}
#[inline]
fn m_lastval() -> i32 {
    M_LASTVAL.with(|c| c.get())
}
#[inline]
fn m_pid() -> i64 {
    M_PID.with(|c| c.get())
}
#[inline]
fn m_pid_set(v: i64) {
    M_PID.with(|c| c.set(v))
}

#[inline]
fn m_error_take() -> Option<String> {
    M_ERROR.with(|c| c.borrow_mut().take())
}
#[inline]
fn m_error_some() -> bool {
    M_ERROR.with(|c| c.borrow().is_some())
}
#[inline]
fn m_error_set(msg: String) {
    M_ERROR.with(|c| {
        if c.borrow().is_none() {
            *c.borrow_mut() = Some(msg);
        }
    })
}
#[inline]
fn m_error_set_force(msg: String) {
    M_ERROR.with(|c| *c.borrow_mut() = Some(msg))
}
#[inline]
fn m_error_clear() {
    M_ERROR.with(|c| *c.borrow_mut() = None)
}

// Stack helpers — mathvalue stack operations.
#[inline]
fn m_stack_push(v: mathvalue) {
    M_STACK.with(|c| c.borrow_mut().push(v))
}
#[inline]
fn m_stack_pop() -> Option<mathvalue> {
    M_STACK.with(|c| c.borrow_mut().pop())
}
#[inline]
fn m_stack_len() -> usize {
    M_STACK.with(|c| c.borrow().len())
}
#[inline]
fn m_stack_is_empty() -> bool {
    M_STACK.with(|c| c.borrow().is_empty())
}
#[inline]
fn m_stack_top_clone() -> Option<mathvalue> {
    M_STACK.with(|c| c.borrow().last().cloned())
}

// Variable map helpers.
#[inline]
fn m_variables_get(name: &str) -> Option<mnumber> {
    M_VARIABLES.with(|c| c.borrow().get(name).copied())
}
#[inline]
fn m_variables_insert(k: String, v: mnumber) {
    M_VARIABLES.with(|c| {
        c.borrow_mut().insert(k, v);
    })
}
#[inline]
fn m_variables_clone() -> HashMap<String, mnumber> {
    M_VARIABLES.with(|c| c.borrow().clone())
}
#[inline]
fn m_variables_set(map: HashMap<String, mnumber>) {
    M_VARIABLES.with(|c| *c.borrow_mut() = map)
}

#[inline]
fn m_string_variables_get(name: &str) -> Option<String> {
    M_STRING_VARIABLES.with(|c| c.borrow().get(name).cloned())
}
#[inline]
fn m_string_variables_remove(name: &str) {
    M_STRING_VARIABLES.with(|c| {
        c.borrow_mut().remove(name);
    })
}
#[inline]
fn m_string_variables_clone() -> HashMap<String, String> {
    M_STRING_VARIABLES.with(|c| c.borrow().clone())
}
#[inline]
fn m_string_variables_set(map: HashMap<String, String>) {
    M_STRING_VARIABLES.with(|c| *c.borrow_mut() = map)
}
#[inline]
fn m_string_variables_insert(k: String, v: String) {
    M_STRING_VARIABLES.with(|c| {
        c.borrow_mut().insert(k, v);
    })
}

/// Save/restore container — mirrors C `mathevall()` (Src/math.c:367)'s
/// stack locals (`xyyval`, `xyylval`, `xunary`, `xnoeval`, `xptr`,
/// etc.). Wrap recursive math eval (`callmathfunc` arg parsing,
/// `getmathparam` indirect-string eval) with `save_state()` /
/// `restore_state()` so the parent's evaluator state survives the
/// inner call's thread_local mutations.
#[allow(non_camel_case_types)]
struct xyy_locals {
    input: String,
    pos: usize,
    tok_start: usize,
    yyval: mnumber,
    yylval: String,
    stack: Vec<mathvalue>,
    mtok: i32,
    unary: bool,
    noeval: i32,
    error: Option<String>,
    variables: HashMap<String, mnumber>,
    string_variables: HashMap<String, String>,
    prec: &'static [u8; TOKCOUNT],
    c_precedences: bool,
    force_float: bool,
    octal_zeroes: bool,
    lastbase: i32,
}

// WARNING: NOT IN MATH.C — Rust-only helper. C inlines the
// xyy* save/restore directly inside `mathevall()`'s body
// (math.c:367 onward); the Rust port factors it out because two
// callsites (callmathfunc arg parsing, getmathparam indirect-string
// eval) would each duplicate ~17 lines of save/restore code.
fn save_state() -> xyy_locals {
    xyy_locals {
        input: m_input_clone(),
        pos: m_pos(),
        tok_start: m_tok_start(),
        yyval: m_yyval(),
        yylval: m_yylval_clone(),
        stack: M_STACK.with(|c| c.borrow().clone()),
        mtok: m_mtok(),
        unary: m_unary(),
        noeval: m_noeval(),
        error: M_ERROR.with(|c| c.borrow().clone()),
        variables: m_variables_clone(),
        string_variables: m_string_variables_clone(),
        prec: m_prec(),
        c_precedences: m_c_precedences(),
        force_float: m_force_float(),
        octal_zeroes: m_octal_zeroes(),
        lastbase: M_LASTBASE.with(|c| c.get()),
    }
}

/// Port of `store(double *x)` from Src/math.c:601 — load/store a double
/// via a pointer to defeat compilers that mis-optimize the
/// canonical `x != x` NaN test. zsh only compiles this path when
/// `HAVE_ISNAN` is undefined; we keep it as a name-parity shim
/// so `isnan()` can route through it (matching the C source's
/// `store(&x) != store(&x)` idiom).
/// WARNING: param names don't match C — Rust=() vs C=(x)
pub(crate) fn store(x: f64) -> f64 {
    x
}

/// Port of `getcvar(char *s)` from Src/math.c:943 — character-constant
/// lookup. Reads the named shell variable and returns the
/// codepoint of its first character. Used for `#varname` token
/// (CId): `x="hello"; (( y = #x ))` puts 104 (`'h'`) into y.
/// On miss or empty value, returns 0 (matches zsh's `*s ? *s : 0`).
/// WARNING: param names don't match C — Rust=() vs C=(s)
pub(crate) fn getcvar(name: &str) -> mnumber {
    if let Some(raw) = m_string_variables_get(name) {
        return mnumber {
            l: raw.chars().next().map(|c| c as i64).unwrap_or(0),
            d: 0.0,
            type_: MN_INTEGER,
        };
    }
    if let Some(v) = m_variables_get(name) {
        let s = match v.type_ {
            MN_INTEGER => v.l.to_string(),
            MN_FLOAT => {
                let f = v.d;
                if isnan(f) {
                    "NaN".to_string()
                } else if isinf(f) {
                    if f > 0.0 {
                        "Inf".to_string()
                    } else {
                        "-Inf".to_string()
                    }
                } else {
                    format!("{:.10}", f)
                }
            }
            _ => "0".to_string(),
        };
        return mnumber {
            l: s.chars().next().map(|c| c as i64).unwrap_or(0),
            d: 0.0,
            type_: MN_INTEGER,
        };
    }
    mnumber {
        l: 0,
        d: 0.0,
        type_: MN_INTEGER,
    }
}

/// Port of `zzlex()` from `Src/math.c:617`.
///
/// Main math-expression lexer — returns the next token, advancing
/// `m_pos()` and updating `m_yyval()` / `m_yylval_clone()` as side-effects.
/// Handles all operators, ident lookahead for `Func` vs `Id`,
/// `[base]value` / `[#base]EXPR` output-radix prefixes, char
/// constants (`#x`, `##varname`), and dispatches numeric literals
/// to `lexconstant()`.
pub(crate) fn zzlex() -> i32 {
    m_yyval_set(mnumber {
        l: 0,
        d: 0.0,
        type_: MN_INTEGER,
    });

    loop {
        let pre_pos = m_pos();
        let c = match advance() {
            Some(c) => c,
            None => {
                m_tok_start_set(pre_pos);
                return EOI;
            }
        };

        if matches!(c, ' ' | '\t' | '\n' | '"') {
            continue;
        }
        // Record where this token began (post-whitespace) so error
        // formatters can produce zsh-style "at `<remaining>`" messages.
        m_tok_start_set(pre_pos);

        match c {
            '+' => {
                if peek() == Some('+') {
                    advance();
                    return if m_unary() { PREPLUS } else { POSTPLUS };
                }
                if peek() == Some('=') {
                    advance();
                    return PLUSEQ;
                }
                return if m_unary() { UPLUS } else { PLUS };
            }

            '-' => {
                if peek() == Some('-') {
                    advance();
                    return if m_unary() { PREMINUS } else { POSTMINUS };
                }
                if peek() == Some('=') {
                    advance();
                    return MINUSEQ;
                }
                if m_unary() {
                    // Check if followed by digit for negative number
                    if let Some(next) = peek() {
                        if is_digit(next) || next == '.' {
                            m_pos_sub(1); // Put back the -
                            return lexconstant();
                        }
                    }
                    return UMINUS;
                }
                return MINUS;
            }

            '(' => return M_INPAR,
            ')' => return M_OUTPAR,

            '!' => {
                if peek() == Some('=') {
                    advance();
                    return NEQ;
                }
                return NOT;
            }

            '~' => return COMP,

            '&' => {
                if peek() == Some('&') {
                    advance();
                    if peek() == Some('=') {
                        advance();
                        return DANDEQ;
                    }
                    return DAND;
                }
                if peek() == Some('=') {
                    advance();
                    return ANDEQ;
                }
                return AND;
            }

            '|' => {
                if peek() == Some('|') {
                    advance();
                    if peek() == Some('=') {
                        advance();
                        return DOREQ;
                    }
                    return DOR;
                }
                if peek() == Some('=') {
                    advance();
                    return OREQ;
                }
                return OR;
            }

            '^' => {
                if peek() == Some('^') {
                    advance();
                    if peek() == Some('=') {
                        advance();
                        return DXOREQ;
                    }
                    return DXOR;
                }
                if peek() == Some('=') {
                    advance();
                    return XOREQ;
                }
                return XOR;
            }

            '*' => {
                if peek() == Some('*') {
                    advance();
                    if peek() == Some('=') {
                        advance();
                        return POWEREQ;
                    }
                    return POWER;
                }
                if peek() == Some('=') {
                    advance();
                    return MULEQ;
                }
                return MUL;
            }

            '/' => {
                if peek() == Some('=') {
                    advance();
                    return DIVEQ;
                }
                return DIV;
            }

            '%' => {
                if peek() == Some('=') {
                    advance();
                    return MODEQ;
                }
                return MOD;
            }

            '<' => {
                if peek() == Some('<') {
                    advance();
                    if peek() == Some('=') {
                        advance();
                        return SHLEFTEQ;
                    }
                    return SHLEFT;
                }
                if peek() == Some('=') {
                    advance();
                    return LEQ;
                }
                return LES;
            }

            '>' => {
                if peek() == Some('>') {
                    advance();
                    if peek() == Some('=') {
                        advance();
                        return SHRIGHTEQ;
                    }
                    return SHRIGHT;
                }
                if peek() == Some('=') {
                    advance();
                    return GEQ;
                }
                return GRE;
            }

            '=' => {
                if peek() == Some('=') {
                    advance();
                    return DEQ;
                }
                return EQ;
            }

            '$' => {
                // $$ = pid
                m_yyval_set(mnumber {
                    l: m_pid(),
                    d: 0.0,
                    type_: MN_INTEGER,
                });
                return NUM;
            }

            '?' => {
                if m_unary() {
                    // $? = lastval
                    m_yyval_set(mnumber {
                        l: m_lastval() as i64,
                        d: 0.0,
                        type_: MN_INTEGER,
                    });
                    return NUM;
                }
                return QUEST;
            }

            ':' => return COLON,
            ',' => return COMMA,

            '[' => {
                // [base]value or output format [#base]
                if is_digit(peek().unwrap_or('\0')) {
                    // [base]value
                    let base_start = m_pos();
                    while let Some(c) = peek() {
                        if is_digit(c) {
                            advance();
                        } else {
                            break;
                        }
                    }
                    if peek() != Some(']') {
                        m_error_set("bad base syntax".to_string());
                        return EOI;
                    }
                    let base_str: String = m_input_clone()[base_start..m_pos()].to_string();
                    let base: u32 = base_str.parse().unwrap_or(10);
                    advance(); // skip ]

                    if !is_digit(peek().unwrap_or('\0')) && !is_ident_start(peek().unwrap_or('\0'))
                    {
                        m_error_set("bad base syntax".to_string());
                        return EOI;
                    }
                    // Reject out-of-range bases; from_str_radix panics
                    // on bases outside [2, 36].
                    if !(2..=36).contains(&base) {
                        m_error_set(format!(
                            "invalid base (must be 2 to 36 inclusive): {}",
                            base
                        ));
                        m_yyval_set(mnumber {
                            l: 0,
                            d: 0.0,
                            type_: MN_INTEGER,
                        });
                        return NUM;
                    }

                    let val_start = m_pos();
                    while let Some(c) = peek() {
                        if c.is_ascii_alphanumeric() {
                            advance();
                        } else {
                            break;
                        }
                    }
                    let val_str = &m_input_clone()[val_start..m_pos()];
                    let val = i64::from_str_radix(val_str, base).unwrap_or(0);
                    m_lastbase_set(base as i32);
                    m_yyval_set(mnumber {
                        l: val,
                        d: 0.0,
                        type_: MN_INTEGER,
                    });
                    return NUM;
                }
                // c:Src/math.c:798-832 — `[#N]` / `[##N]` / `[#_M]`
                // output format specifier. Set outputradix to ±N and
                // outputunderscore to M (digit-grouping width).
                //
                //   `[#N]`        outputradix = +N    (emit `N#` prefix)
                //   `[##N]`       outputradix = -N    (bare digits, no prefix)
                //   `[#N_M]`      ... plus underscore every M digits
                //   `[#_M]`       outputradix unchanged, underscore = M
                //   `[#_]`        outputradix unchanged, underscore = 3 (default)
                //
                // Previous Rust port matched `[#…]` and SILENTLY DROPPED
                // the directive, so `$(([##16] 255))` returned `255` (decimal)
                // instead of `FF`. p10k uses `[##16]` in glyph-code emitters
                // and `[#16]` in icon-byte formatting; both were broken.
                if peek() == Some('#') {
                    advance(); // c:798 — skip first `#`
                    let mut n: i32 = 1; // c:799
                    if peek() == Some('#') {
                        // c:800 — second `#` flips sign for "no prefix"
                        n = -1; // c:801
                        advance(); // c:802
                    }
                    let p_now = peek().unwrap_or('\0');
                    if !is_digit(p_now) && p_now != '_' {
                        // c:804-805
                        m_error_set("bad output format specification".to_string());
                        return EOI;
                    }
                    let mut checkradix = false;
                    if is_digit(p_now) {
                        // c:806-809 — `outputradix = n * zstrtol(ptr, &ptr, 10);`
                        let rstart = m_pos();
                        while let Some(c) = peek() {
                            if is_digit(c) {
                                advance();
                            } else {
                                break;
                            }
                        }
                        let radix_str: String =
                            m_input_clone()[rstart..m_pos()].to_string();
                        let radix: i32 = radix_str.parse().unwrap_or(10);
                        m_outputradix_set(n * radix); // c:807
                        checkradix = true; // c:808
                    }
                    if peek() == Some('_') {
                        // c:810-816 — `[…_M]` underscore digit-grouping width.
                        advance(); // c:811
                        let us_now = peek().unwrap_or('\0');
                        if is_digit(us_now) {
                            let ustart = m_pos();
                            while let Some(c) = peek() {
                                if is_digit(c) {
                                    advance();
                                } else {
                                    break;
                                }
                            }
                            let us_str: String =
                                m_input_clone()[ustart..m_pos()].to_string();
                            m_outputunderscore_set(us_str.parse().unwrap_or(3));
                            // c:812-813
                        } else {
                            m_outputunderscore_set(3); // c:814-815 default
                        }
                    }
                    if peek() != Some(']') {
                        // c:822-823
                        m_error_set("bad output format specification".to_string());
                        return EOI;
                    }
                    advance(); // c:832 — skip `]`
                    if checkradix {
                        // c:824-831 — validate base ∈ [2, 36].
                        let abs_n = M_OUTPUTRADIX.with(|c| c.get()).abs();
                        if !(2..=36).contains(&abs_n) {
                            m_error_set(format!(
                                "invalid base (must be 2 to 36 inclusive): {}",
                                M_OUTPUTRADIX.with(|c| c.get())
                            ));
                            return EOI;
                        }
                    }
                    // c:833 — `break;` — fall through to the next token
                    // (the format directive doesn't yield a NUM itself).
                    continue;
                }
                m_error_set("bad output format specification".to_string());
                return EOI;
            }

            '#' => {
                // Character code: #\x or ##string
                if peek() == Some('\\') || peek() == Some('#') {
                    advance();
                    if let Some(ch) = advance() {
                        m_yyval_set(mnumber {
                            l: ch as i64,
                            d: 0.0,
                            type_: MN_INTEGER,
                        });
                        return NUM;
                    }
                }
                // #varname - get first char value
                let id_start = m_pos();
                while let Some(c) = peek() {
                    if is_ident(c) {
                        advance();
                    } else {
                        break;
                    }
                }
                if m_pos() > id_start {
                    m_yylval_set(m_input_clone()[id_start..m_pos()].to_string());
                    return CID;
                }
                continue;
            }

            _ => {
                if is_digit(c) || (c == '.' && is_digit(peek().unwrap_or('\0'))) {
                    m_pos_sub(c.len_utf8());
                    return lexconstant();
                }

                if is_ident_start(c) {
                    let id_start = m_pos() - c.len_utf8();
                    while let Some(c) = peek() {
                        if is_ident(c) {
                            advance();
                        } else {
                            break;
                        }
                    }

                    let id = &m_input_clone()[id_start..m_pos()];

                    // Check for Inf/NaN
                    let id_lower = id.to_lowercase();
                    if id_lower == "nan" {
                        m_yyval_set(mnumber {
                            l: 0,
                            d: f64::NAN,
                            type_: MN_FLOAT,
                        });
                        return NUM;
                    }
                    if id_lower == "inf" {
                        m_yyval_set(mnumber {
                            l: 0,
                            d: f64::INFINITY,
                            type_: MN_FLOAT,
                        });
                        return NUM;
                    }

                    // Check for function call
                    if peek() == Some('(') {
                        // Skip to closing paren
                        let func_start = id_start;
                        advance(); // (
                        let mut depth = 1;
                        while let Some(c) = peek() {
                            advance();
                            if c == '(' {
                                depth += 1;
                            } else if c == ')' {
                                depth -= 1;
                                if depth == 0 {
                                    break;
                                }
                            }
                        }
                        m_yylval_set(m_input_clone()[func_start..m_pos()].to_string());
                        return FUNC;
                    }

                    // Check for array subscript
                    if peek() == Some('[') {
                        advance(); // [
                        let mut depth = 1;
                        while let Some(c) = peek() {
                            advance();
                            if c == '[' {
                                depth += 1;
                            } else if c == ']' {
                                depth -= 1;
                                if depth == 0 {
                                    break;
                                }
                            }
                        }
                    }

                    m_yylval_set(m_input_clone()[id_start..m_pos()].to_string());
                    return ID;
                }

                return EOI;
            }
        }
    }
}

impl Default for mathvalue {
    fn default() -> Self {
        mathvalue {
            val: mnumber {
                l: 0,
                d: 0.0,
                type_: MN_INTEGER,
            },
            lval: None,
            pval: (),
        }
    }
}

/// Port of `push(mnumber val, char *lval, int getme)` from `Src/math.c:916`.
///
/// Push a value onto the evaluator's operand stack, with the
/// optional lvalue name (set when the value came from a variable
/// reference; needed for `++`/`--`/assignment-op write-back).
/// WARNING: param names don't match C — Rust=(lval) vs C=(val, lval, getme)
pub(crate) fn push(val: mnumber, lval: Option<String>) {
    m_stack_push(mathvalue {
        val,
        lval,
        pval: (),
    });
}

/// Port of `pop(int noget)` from `Src/math.c:931`.
///
/// Pop the top operand from the stack, resolving any deferred
/// variable read (`mnumber { l: 0, d: 0.0, type_: MN_UNSET }` + lval set). The C source
/// passes a `noget` flag to skip the resolution; the Rust port
/// always resolves since callers that want the raw lvalue use
/// `pop_with_lval` instead.
/// WARNING: param names don't match C — Rust=() vs C=(noget)
pub(crate) fn pop() -> mnumber {
    if let Some(mv) = m_stack_pop() {
        if (mv.val.type_ == MN_UNSET) {
            if let Some(ref name) = mv.lval {
                return getmathparam(name);
            }
        }
        mv.val
    } else {
        m_error_set("stack underflow".to_string());
        mnumber {
            l: 0,
            d: 0.0,
            type_: MN_INTEGER,
        }
    }
}

/// Port of `setmathvar(struct mathvalue *mvp, mnumber v)` from `Src/math.c:972`.
///
/// Write `val` to the named parameter from inside math context.
/// Port of `setmathvar(struct mathvalue *mvp, mnumber v)` from `Src/math.c:972`.
/// Calls `setnparam` (the canonical param-set) and returns the value
/// re-typed to match the parameter's type (C c:1014-1027).
pub(crate) fn setmathvar(name: &str, val: mnumber) -> mnumber {
    // c:972
    // c:996-1001 — bad-lvalue check (empty name).
    if name.is_empty() {
        zerr("bad math expression: lvalue required");
        return mnumber {
            l: 0,
            d: 0.0,
            type_: MN_INTEGER,
        };
    }
    // c:1002-1003 — `if (noeval) return v;`
    if M_NOEVAL.with(|n| n.get()) != 0 {
        return val;
    }
    // Extract base name for subscripted writes; subscript handling
    // already done by SubscriptArith higher up.
    let base_name = if let Some(bracket) = name.find('[') {
        &name[..bracket]
    } else {
        name
    };
    // Cache into math-local m_variables so subsequent reads in the
    // same math expression see the new value without a paramtab
    // round-trip. The canonical paramtab write below is what makes
    // the value persist beyond the current $((…)) evaluation.
    m_variables_insert(base_name.to_string(), val);
    // c:1005 — `pm = setnparam(mvp->lval, v);`
    let pm = crate::ported::params::setnparam(base_name, val);
    // c:1006-1027 — re-type the return per the param's type after setnparam.
    if let Some(pm) = pm {
        let flags = pm.node.flags as u32;
        if flags & PM_INTEGER != 0 {
            let l = if val.type_ == MN_FLOAT {
                val.d as i64
            } else {
                val.l
            };
            return mnumber {
                l,
                d: 0.0,
                type_: MN_INTEGER,
            };
        }
        if flags & (PM_EFLOAT | PM_FFLOAT) != 0 {
            let d = if val.type_ == MN_INTEGER {
                val.l as f64
            } else {
                val.d
            };
            return mnumber {
                l: 0,
                d,
                type_: MN_FLOAT,
            };
        }
    }
    val
}

/// Call a math function
/// Port of `callmathfunc(char *o)` from `Src/math.c:1037`.
/// WARNING: param names don't match C — Rust=() vs C=(o)
pub(crate) fn callmathfunc(call: &str) -> mnumber {
    // Parse function name and args
    let paren = call.find('(').unwrap_or(call.len());
    let name = &call[..paren];
    // c:Src/math.c:1037 — `callmathfunc` looks up `name` in the
    // global `mathfuncs` table. The table is empty until
    // `zmodload zsh/mathfunc` (Src/Modules/mathfunc.c mtab[]) is
    // loaded. Without it, every named call fails with "unknown
    // function: NAME" (Src/math.c:1066). The previous Rust port
    // unconditionally dispatched against the built-in match arms,
    // auto-loading the module's contents — `zsh -fc 'echo
    // $((sqrt(4)))'` should exit 1, not silently return `2.`.
    let is_module_func = matches!(
        name,
        "abs" | "acos" | "acosh" | "asin" | "asinh" | "atan" | "atan2"
        | "atanh" | "cbrt" | "ceil" | "cos" | "cosh" | "erf" | "erfc"
        | "exp" | "expm1" | "fabs" | "float" | "floor" | "gamma"
        | "hypot" | "ilogb" | "int" | "j0" | "j1" | "lgamma" | "log"
        | "log10" | "log1p" | "log2" | "logb" | "max" | "min"
        | "nextafter" | "pow" | "rand" | "round" | "sin" | "sinh"
        | "sqrt" | "tan" | "tanh" | "trunc" | "y0" | "y1"
    );
    // c:Src/module.c:2206-2322 `load_module` — the post-init flag
    // signaling "this module's setup/boot ran" is MOD_INIT_B (set
    // at c:2322 after do_boot_module). MOD_LINKED alone is just
    // "statically linkable" and is pre-set for every builtin
    // module at registration time in modulestab::init_builtin
    // (zsh_h.rs:758) — so it's true even before any `zmodload`.
    // Gate on MOD_INIT_B to mirror C's "the module's mtab[] is
    // currently in the global mathfuncs table".
    let module_loaded = crate::ported::module::MODULESTAB
        .lock()
        .ok()
        .and_then(|tab| {
            tab.modules.get("zsh/mathfunc").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(false);
    if is_module_func && !module_loaded {
        crate::ported::utils::zerr(&format!("unknown function: {}", name));
        crate::ported::utils::errflag.fetch_or(
            crate::ported::zsh_h::ERRFLAG_ERROR,
            std::sync::atomic::Ordering::Relaxed,
        );
        return mnumber {
            l: 0,
            d: 0.0,
            type_: MN_INTEGER,
        };
    }
    let args_str = if paren < call.len() {
        &call[paren + 1..call.len() - 1]
    } else {
        ""
    };

    // Parse arguments. Keep both the float view (for trig) and the
    // original mnumber so int-preserving functions (abs/min/max/
    // int/floor/ceil/trunc) can return integer when all inputs
    // were integer.
    let arg_nums: Vec<mnumber> = if args_str.is_empty() {
        vec![]
    } else {
        args_str
            .split(',')
            .filter_map(|arg| {
                // Save caller's eval state, sub-eval each arg in a
                // fresh state inheriting caller's variables, restore.
                // C `mathevall()` xyy* save/restore (math.c:367).
                let saved = save_state();
                let inherited_vars = saved.variables.clone();
                new(arg.trim());
                m_variables_set(inherited_vars);
                let result = mathevall();
                restore_state(saved);
                // c:math.c::callmathfunc — when a function-arg subeval
                // fails, the C body's mathevall has already zerr'd the
                // parse error. Rust's mathevall captures the message
                // in Err; the previous .ok() discarded it silently,
                // so `$(( abs(1 2) ))` returned 0 instead of erroring.
                match result {
                    Ok(n) => Some(n),
                    Err(msg) => {
                        crate::ported::utils::zerr(&msg);
                        None
                    }
                }
            })
            .collect()
    };
    let args: Vec<f64> = arg_nums
        .iter()
        .map(|n| (if n.type_ == MN_FLOAT { n.d } else { n.l as f64 }))
        .collect();
    let all_int = !arg_nums.is_empty() && arg_nums.iter().all(|n| (n.type_ == MN_INTEGER));

    // c:Src/Modules/mathfunc.c:139 — only `int` has TFLAG(TF_NOASS)
    // which collapses the result to MN_INTEGER. `ceil`/`floor` lack
    // TF_NOASS so they return float (rendered as `5.` for whole
    // values), and `trunc` doesn't exist in zsh's mathfunc table.
    // The previous Rust port forced all four to integer, so
    // `$(( ceil(1.1) ))` printed `2` instead of zsh's `2.`.
    let always_int = matches!(name, "int" | "trunc");
    if always_int {
        let i = match name {
            "int" | "trunc" => arg_nums
                .first()
                .map(|n| (if n.type_ == MN_FLOAT { n.d as i64 } else { n.l }))
                .unwrap_or(0),
            _ => 0,
        };
        return mnumber {
            l: i,
            d: 0.0,
            type_: MN_INTEGER,
        };
    }
    let int_preserving = matches!(name, "abs" | "min" | "max");
    if all_int && int_preserving {
        let i = match name {
            "abs" => arg_nums
                .first()
                .map(|n| (if n.type_ == MN_FLOAT { n.d as i64 } else { n.l }).abs())
                .unwrap_or(0),
            "min" => arg_nums
                .iter()
                .map(|n| (if n.type_ == MN_FLOAT { n.d as i64 } else { n.l }))
                .min()
                .unwrap_or(0),
            "max" => arg_nums
                .iter()
                .map(|n| (if n.type_ == MN_FLOAT { n.d as i64 } else { n.l }))
                .max()
                .unwrap_or(0),
            _ => 0,
        };
        return mnumber {
            l: i,
            d: 0.0,
            type_: MN_INTEGER,
        };
    }

    // Built-in math functions
    let result = match name {
        "abs" => args.first().map(|x| x.abs()).unwrap_or(0.0),
        "acos" => args.first().map(|x| x.acos()).unwrap_or(0.0),
        "asin" => args.first().map(|x| x.asin()).unwrap_or(0.0),
        "atan" => args.first().map(|x| x.atan()).unwrap_or(0.0),
        "atan2" => {
            let y = args.first().copied().unwrap_or(0.0);
            let x = args.get(1).copied().unwrap_or(1.0);
            y.atan2(x)
        }
        "ceil" => args.first().map(|x| x.ceil()).unwrap_or(0.0),
        "cos" => args.first().map(|x| x.cos()).unwrap_or(1.0),
        "cosh" => args.first().map(|x| x.cosh()).unwrap_or(1.0),
        "exp" => args.first().map(|x| x.exp()).unwrap_or(1.0),
        "floor" => args.first().map(|x| x.floor()).unwrap_or(0.0),
        "hypot" => {
            let x = args.first().copied().unwrap_or(0.0);
            let y = args.get(1).copied().unwrap_or(0.0);
            x.hypot(y)
        }
        "int" => args.first().map(|x| x.trunc()).unwrap_or(0.0),
        "log" => args.first().map(|x| x.ln()).unwrap_or(0.0),
        "log10" => args.first().map(|x| x.log10()).unwrap_or(0.0),
        "log2" => args.first().map(|x| x.log2()).unwrap_or(0.0),
        "max" => args.iter().copied().fold(f64::NEG_INFINITY, f64::max),
        "min" => args.iter().copied().fold(f64::INFINITY, f64::min),
        "pow" => {
            let base = args.first().copied().unwrap_or(0.0);
            let exp = args.get(1).copied().unwrap_or(1.0);
            base.powf(exp)
        }
        "rand" => rand::random::<f64>(),
        "round" => args.first().map(|x| x.round()).unwrap_or(0.0),
        "sin" => args.first().map(|x| x.sin()).unwrap_or(0.0),
        "sinh" => args.first().map(|x| x.sinh()).unwrap_or(0.0),
        "sqrt" => args.first().map(|x| x.sqrt()).unwrap_or(0.0),
        "tan" => args.first().map(|x| x.tan()).unwrap_or(0.0),
        "tanh" => args.first().map(|x| x.tanh()).unwrap_or(0.0),
        "trunc" => args.first().map(|x| x.trunc()).unwrap_or(0.0),
        // `float(x)` — widen int/float to float. Identity on
        // floats; on ints, returns same value tagged as float so
        // `printf "%.4f"` prints "3.0000" instead of "3". Direct
        // port of mathfunc.c's `to_float()`.
        "float" => args.first().copied().unwrap_or(0.0),
        _ => {
            m_error_set(format!("unknown function: {}", name));
            0.0
        }
    };

    mnumber {
        l: 0,
        d: result,
        type_: MN_FLOAT,
    }
}

/// Port of `op(int what)` from `Src/math.c:1154`.
///
/// Apply a binary or unary operator to the operand stack. Pops
/// 1-2 values, applies the operation (with type coercion), and
/// pushes the result. Handles assignment (`OP_E2*` flag) by
/// writing through `setmathvar` and pushing the new value back
/// with the same lvalue so chained assigns work.
/// WARNING: param names don't match C — Rust=() vs C=(what)
pub(crate) fn op(what: i32) {
    if m_error_some() {
        return;
    }

    let tp = OP_TYPE[what as usize];

    // Binary operators
    if (tp & (OP_A2 | OP_A2IR | OP_A2IO | OP_E2 | OP_E2IO)) != 0 {
        if m_stack_len() < 2 {
            // zsh's exact wording for the same condition is
            // `bad math expression: operand expected at end of
            // string`. Matching it here means `let "1+"` and
            // `$((5+))` produce the same diagnostic shape that
            // scripts grep for.
            m_error_set("bad math expression: operand expected at end of string".to_string());
            return;
        }

        let b = pop();
        let mv_a = pop_with_lval();
        let a = if (mv_a.val.type_ == MN_UNSET) {
            if let Some(ref name) = mv_a.lval {
                getmathparam(name)
            } else {
                mnumber {
                    l: 0,
                    d: 0.0,
                    type_: MN_INTEGER,
                }
            }
        } else {
            mv_a.val
        };

        // Coerce types
        let (a, b) = if (tp & (OP_A2IO | OP_E2IO)) != 0 {
            // Must be integers
            (
                mnumber {
                    l: (if a.type_ == MN_FLOAT { a.d as i64 } else { a.l }),
                    d: 0.0,
                    type_: MN_INTEGER,
                },
                mnumber {
                    l: (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }),
                    d: 0.0,
                    type_: MN_INTEGER,
                },
            )
        } else if (a.type_ == MN_FLOAT) != (b.type_ == MN_FLOAT) && what != COMMA {
            // Different types, coerce to float
            (
                mnumber {
                    l: 0,
                    d: (if a.type_ == MN_FLOAT { a.d } else { a.l as f64 }),
                    type_: MN_FLOAT,
                },
                mnumber {
                    l: 0,
                    d: (if b.type_ == MN_FLOAT { b.d } else { b.l as f64 }),
                    type_: MN_FLOAT,
                },
            )
        } else {
            (a, b)
        };

        let result = if m_noeval() > 0 {
            mnumber {
                l: 0,
                d: 0.0,
                type_: MN_INTEGER,
            }
        } else {
            let is_float = (a.type_ == MN_FLOAT);
            match what {
                AND | ANDEQ => mnumber {
                    l: (if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                        & (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }),
                    d: 0.0,
                    type_: MN_INTEGER,
                },
                XOR | XOREQ => mnumber {
                    l: (if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                        ^ (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }),
                    d: 0.0,
                    type_: MN_INTEGER,
                },
                OR | OREQ => mnumber {
                    l: (if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                        | (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }),
                    d: 0.0,
                    type_: MN_INTEGER,
                },

                MUL | MULEQ => {
                    if is_float {
                        mnumber {
                            l: 0,
                            d: (if a.type_ == MN_FLOAT { a.d } else { a.l as f64 })
                                * (if b.type_ == MN_FLOAT { b.d } else { b.l as f64 }),
                            type_: MN_FLOAT,
                        }
                    } else {
                        mnumber {
                            l: (if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                                .wrapping_mul((if b.type_ == MN_FLOAT { b.d as i64 } else { b.l })),
                            d: 0.0,
                            type_: MN_INTEGER,
                        }
                    }
                }

                DIV | DIVEQ => {
                    // Float div-by-zero is NOT an error in zsh —
                    // it produces IEEE Inf/-Inf/NaN per IEEE 754.
                    // Only INTEGER div-by-zero raises the error.
                    // Without this gate `1/0.0` errored out instead
                    // of returning `Inf`.
                    if is_float {
                        // Let f64 semantics handle 0.0, -0.0, NaN.
                        mnumber {
                            l: 0,
                            d: (if a.type_ == MN_FLOAT { a.d } else { a.l as f64 })
                                / (if b.type_ == MN_FLOAT { b.d } else { b.l as f64 }),
                            type_: MN_FLOAT,
                        }
                    } else {
                        if !notzero(b) {
                            m_error_set("division by zero".to_string());
                            return;
                        }
                        let bi = (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l });
                        if bi == -1 {
                            mnumber {
                                l: (if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                                    .wrapping_neg(),
                                d: 0.0,
                                type_: MN_INTEGER,
                            }
                        } else {
                            mnumber {
                                l: (if a.type_ == MN_FLOAT { a.d as i64 } else { a.l }) / bi,
                                d: 0.0,
                                type_: MN_INTEGER,
                            }
                        }
                    }
                }

                MOD | MODEQ => {
                    if is_float {
                        // float % 0.0 → NaN per IEEE; let it fall
                        // through to f64 semantics rather than
                        // raising the integer-only error.
                        mnumber {
                            l: 0,
                            d: (if a.type_ == MN_FLOAT { a.d } else { a.l as f64 })
                                % (if b.type_ == MN_FLOAT { b.d } else { b.l as f64 }),
                            type_: MN_FLOAT,
                        }
                    } else if !notzero(b) {
                        m_error_set("division by zero".to_string());
                        return;
                    } else {
                        let bi = (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l });
                        if bi == -1 {
                            mnumber {
                                l: 0,
                                d: 0.0,
                                type_: MN_INTEGER,
                            }
                        } else {
                            mnumber {
                                l: (if a.type_ == MN_FLOAT { a.d as i64 } else { a.l }) % bi,
                                d: 0.0,
                                type_: MN_INTEGER,
                            }
                        }
                    }
                }

                PLUS | PLUSEQ => {
                    if is_float {
                        mnumber {
                            l: 0,
                            d: (if a.type_ == MN_FLOAT { a.d } else { a.l as f64 })
                                + (if b.type_ == MN_FLOAT { b.d } else { b.l as f64 }),
                            type_: MN_FLOAT,
                        }
                    } else {
                        mnumber {
                            l: (if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                                .wrapping_add((if b.type_ == MN_FLOAT { b.d as i64 } else { b.l })),
                            d: 0.0,
                            type_: MN_INTEGER,
                        }
                    }
                }

                MINUS | MINUSEQ => {
                    if is_float {
                        mnumber {
                            l: 0,
                            d: (if a.type_ == MN_FLOAT { a.d } else { a.l as f64 })
                                - (if b.type_ == MN_FLOAT { b.d } else { b.l as f64 }),
                            type_: MN_FLOAT,
                        }
                    } else {
                        mnumber {
                            l: (if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                                .wrapping_sub((if b.type_ == MN_FLOAT { b.d as i64 } else { b.l })),
                            d: 0.0,
                            type_: MN_INTEGER,
                        }
                    }
                }

                SHLEFT | SHLEFTEQ => mnumber {
                    l: (if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                        << ((if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }) as u32 & 63),
                    d: 0.0,
                    type_: MN_INTEGER,
                },
                SHRIGHT | SHRIGHTEQ => mnumber {
                    l: (if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                        >> ((if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }) as u32 & 63),
                    d: 0.0,
                    type_: MN_INTEGER,
                },

                LES => mnumber {
                    l: if is_float {
                        ((if a.type_ == MN_FLOAT { a.d } else { a.l as f64 })
                            < (if b.type_ == MN_FLOAT { b.d } else { b.l as f64 }))
                            as i64
                    } else {
                        ((if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                            < (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }))
                            as i64
                    },
                    d: 0.0,
                    type_: MN_INTEGER,
                },
                LEQ => mnumber {
                    l: if is_float {
                        ((if a.type_ == MN_FLOAT { a.d } else { a.l as f64 })
                            <= (if b.type_ == MN_FLOAT { b.d } else { b.l as f64 }))
                            as i64
                    } else {
                        ((if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                            <= (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }))
                            as i64
                    },
                    d: 0.0,
                    type_: MN_INTEGER,
                },
                GRE => mnumber {
                    l: if is_float {
                        ((if a.type_ == MN_FLOAT { a.d } else { a.l as f64 })
                            > (if b.type_ == MN_FLOAT { b.d } else { b.l as f64 }))
                            as i64
                    } else {
                        ((if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                            > (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }))
                            as i64
                    },
                    d: 0.0,
                    type_: MN_INTEGER,
                },
                GEQ => mnumber {
                    l: if is_float {
                        ((if a.type_ == MN_FLOAT { a.d } else { a.l as f64 })
                            >= (if b.type_ == MN_FLOAT { b.d } else { b.l as f64 }))
                            as i64
                    } else {
                        ((if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                            >= (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }))
                            as i64
                    },
                    d: 0.0,
                    type_: MN_INTEGER,
                },
                DEQ => mnumber {
                    l: if is_float {
                        ((if a.type_ == MN_FLOAT { a.d } else { a.l as f64 })
                            == (if b.type_ == MN_FLOAT { b.d } else { b.l as f64 }))
                            as i64
                    } else {
                        ((if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                            == (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }))
                            as i64
                    },
                    d: 0.0,
                    type_: MN_INTEGER,
                },
                NEQ => mnumber {
                    l: if is_float {
                        ((if a.type_ == MN_FLOAT { a.d } else { a.l as f64 })
                            != (if b.type_ == MN_FLOAT { b.d } else { b.l as f64 }))
                            as i64
                    } else {
                        ((if a.type_ == MN_FLOAT { a.d as i64 } else { a.l })
                            != (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }))
                            as i64
                    },
                    d: 0.0,
                    type_: MN_INTEGER,
                },

                DAND | DANDEQ => mnumber {
                    l: ((if a.type_ == MN_FLOAT { a.d as i64 } else { a.l }) != 0
                        && (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }) != 0)
                        as i64,
                    d: 0.0,
                    type_: MN_INTEGER,
                },
                DOR | DOREQ => mnumber {
                    l: ((if a.type_ == MN_FLOAT { a.d as i64 } else { a.l }) != 0
                        || (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }) != 0)
                        as i64,
                    d: 0.0,
                    type_: MN_INTEGER,
                },
                DXOR | DXOREQ => {
                    let ai = (if a.type_ == MN_FLOAT { a.d as i64 } else { a.l }) != 0;
                    let bi = (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l }) != 0;
                    mnumber {
                        l: (ai != bi) as i64,
                        d: 0.0,
                        type_: MN_INTEGER,
                    }
                }

                POWER | POWEREQ => {
                    let bi = (if b.type_ == MN_FLOAT { b.d as i64 } else { b.l });
                    if !is_float && bi >= 0 {
                        let mut result = 1i64;
                        let base = (if a.type_ == MN_FLOAT { a.d as i64 } else { a.l });
                        for _ in 0..bi {
                            result = result.wrapping_mul(base);
                        }
                        mnumber {
                            l: result,
                            d: 0.0,
                            type_: MN_INTEGER,
                        }
                    } else {
                        let af = (if a.type_ == MN_FLOAT { a.d } else { a.l as f64 });
                        let bf = (if b.type_ == MN_FLOAT { b.d } else { b.l as f64 });
                        if bf <= 0.0 && af == 0.0 {
                            m_error_set("division by zero".to_string());
                            return;
                        }
                        if af < 0.0 && bf != bf.trunc() {
                            m_error_set("imaginary power".to_string());
                            return;
                        }
                        mnumber {
                            l: 0,
                            d: af.powf(bf),
                            type_: MN_FLOAT,
                        }
                    }
                }

                COMMA => b,
                EQ => b,

                _ => mnumber {
                    l: 0,
                    d: 0.0,
                    type_: MN_INTEGER,
                },
            }
        };

        // Handle assignment
        if (tp & (OP_E2 | OP_E2IO)) != 0 {
            if let Some(ref name) = mv_a.lval {
                let final_val = setmathvar(name, result);
                push(final_val, Some(name.clone()));
            } else {
                m_error_set("lvalue required".to_string());
                push(
                    mnumber {
                        l: 0,
                        d: 0.0,
                        type_: MN_INTEGER,
                    },
                    None,
                );
            }
        } else {
            push(result, None);
        }
        return;
    }

    // Unary operators
    if m_stack_is_empty() {
        // zsh: unary op with empty stack -> `bad math
        // expression: operand expected at end of string`.
        // zshrs's bare `stack empty` had no match for scripts
        // grepping zsh's canonical wording.
        m_error_set("bad math expression: operand expected at end of string".to_string());
        return;
    }

    let mv = pop_with_lval();
    let val = if (mv.val.type_ == MN_UNSET) {
        if let Some(ref name) = mv.lval {
            getmathparam(name)
        } else {
            mnumber {
                l: 0,
                d: 0.0,
                type_: MN_INTEGER,
            }
        }
    } else {
        mv.val
    };

    match what {
        NOT => {
            let result = mnumber {
                l: if ((val.type_ == MN_INTEGER && val.l == 0)
                    || (val.type_ == MN_FLOAT && val.d == 0.0)
                    || val.type_ == MN_UNSET)
                {
                    1
                } else {
                    0
                },
                d: 0.0,
                type_: MN_INTEGER,
            };
            push(result, None);
        }
        COMP => {
            let result = mnumber {
                l: !(if val.type_ == MN_FLOAT {
                    val.d as i64
                } else {
                    val.l
                }),
                d: 0.0,
                type_: MN_INTEGER,
            };
            push(result, None);
        }
        UPLUS => {
            push(val, None);
        }
        UMINUS => {
            let result = if (val.type_ == MN_FLOAT) {
                mnumber {
                    l: 0,
                    d: -(if val.type_ == MN_FLOAT {
                        val.d
                    } else {
                        val.l as f64
                    }),
                    type_: MN_FLOAT,
                }
            } else {
                mnumber {
                    l: -(if val.type_ == MN_FLOAT {
                        val.d as i64
                    } else {
                        val.l
                    }),
                    d: 0.0,
                    type_: MN_INTEGER,
                }
            };
            push(result, None);
        }
        POSTPLUS => {
            // ++/-- on a literal (`5++`, `--5`) is a zsh error:
            // "bad math expression: lvalue required". Without the
            // mv.lval guard, zshrs silently incremented the
            // literal value and returned it, masking the bug.
            if mv.lval.is_none() {
                m_error_set("bad math expression: lvalue required".to_string());
                return;
            }
            let name = mv.lval.as_ref().unwrap();
            let new_val = if (val.type_ == MN_FLOAT) {
                mnumber {
                    l: 0,
                    d: (if val.type_ == MN_FLOAT {
                        val.d
                    } else {
                        val.l as f64
                    }) + 1.0,
                    type_: MN_FLOAT,
                }
            } else {
                mnumber {
                    l: (if val.type_ == MN_FLOAT {
                        val.d as i64
                    } else {
                        val.l
                    }) + 1,
                    d: 0.0,
                    type_: MN_INTEGER,
                }
            };
            setmathvar(name, new_val);
            push(val, None); // Return original value
        }
        POSTMINUS => {
            if mv.lval.is_none() {
                m_error_set("bad math expression: lvalue required".to_string());
                return;
            }
            let name = mv.lval.as_ref().unwrap();
            let new_val = if (val.type_ == MN_FLOAT) {
                mnumber {
                    l: 0,
                    d: (if val.type_ == MN_FLOAT {
                        val.d
                    } else {
                        val.l as f64
                    }) - 1.0,
                    type_: MN_FLOAT,
                }
            } else {
                mnumber {
                    l: (if val.type_ == MN_FLOAT {
                        val.d as i64
                    } else {
                        val.l
                    }) - 1,
                    d: 0.0,
                    type_: MN_INTEGER,
                }
            };
            setmathvar(name, new_val);
            push(val, None);
        }
        PREPLUS => {
            if mv.lval.is_none() {
                m_error_set("bad math expression: lvalue required".to_string());
                return;
            }
            let name = mv.lval.as_ref().unwrap();
            let new_val = if (val.type_ == MN_FLOAT) {
                mnumber {
                    l: 0,
                    d: (if val.type_ == MN_FLOAT {
                        val.d
                    } else {
                        val.l as f64
                    }) + 1.0,
                    type_: MN_FLOAT,
                }
            } else {
                mnumber {
                    l: (if val.type_ == MN_FLOAT {
                        val.d as i64
                    } else {
                        val.l
                    }) + 1,
                    d: 0.0,
                    type_: MN_INTEGER,
                }
            };
            setmathvar(name, new_val);
            push(new_val, mv.lval);
        }
        PREMINUS => {
            if mv.lval.is_none() {
                m_error_set("bad math expression: lvalue required".to_string());
                return;
            }
            let name = mv.lval.as_ref().unwrap();
            let new_val = if (val.type_ == MN_FLOAT) {
                mnumber {
                    l: 0,
                    d: (if val.type_ == MN_FLOAT {
                        val.d
                    } else {
                        val.l as f64
                    }) - 1.0,
                    type_: MN_FLOAT,
                }
            } else {
                mnumber {
                    l: (if val.type_ == MN_FLOAT {
                        val.d as i64
                    } else {
                        val.l
                    }) - 1,
                    d: 0.0,
                    type_: MN_INTEGER,
                }
            };
            setmathvar(name, new_val);
            push(new_val, mv.lval);
        }
        QUEST => {
            // Ternary: stack has [cond, true_val, false_val]
            // val already popped = false_val
            // Need to pop true_val and cond
            if m_stack_len() < 2 {
                m_error_set("?: needs 3 operands".to_string());
                return;
            }
            let false_val = val;
            let true_val = pop();
            let cond = pop();
            let result = if !((cond.type_ == MN_INTEGER && cond.l == 0)
                || (cond.type_ == MN_FLOAT && cond.d == 0.0)
                || cond.type_ == MN_UNSET)
            {
                true_val
            } else {
                false_val
            };
            push(result, None);
        }
        COLON => {
            m_error_set("':' without '?'".to_string());
        }
        _ => {
            m_error_set("unknown operator".to_string());
        }
    }
}

/// Port of `bop(int tk)` from `Src/math.c:1454`.
///
/// Short-circuit boolean prologue. Inspects (without popping) the
/// top of stack and bumps `m_noeval()` for the parse-only side of
/// `&&` / `||` / their assignment forms. The matching decrement
/// happens after `mathparse` recurses for the RHS.
/// WARNING: param names don't match C — Rust=() vs C=(tk)
pub(crate) fn bop(tk: i32) {
    if m_stack_is_empty() {
        return;
    }
    let mv = m_stack_top_clone().unwrap();
    let val = if (mv.val.type_ == MN_UNSET) {
        if let Some(ref name) = mv.lval {
            getmathparam(name)
        } else {
            mnumber {
                l: 0,
                d: 0.0,
                type_: MN_INTEGER,
            }
        }
    } else {
        mv.val
    };

    let tst = !((val.type_ == MN_INTEGER && val.l == 0)
        || (val.type_ == MN_FLOAT && val.d == 0.0)
        || val.type_ == MN_UNSET);
    match tk {
        DAND | DANDEQ if !tst => {
            m_noeval_inc();
        }
        DOR | DOREQ if tst => {
            m_noeval_inc();
        }
        _ => {}
    }
}

/// Port of `mnumber matheval(char *s)` from `Src/math.c:1480`.
///
/// C body (c:1481-1500):
/// ```c
/// char *junk;
/// mnumber x;
/// int xmtok = mtok;
/// /* maintain outputradix and outputunderscore across levels of evaluation */
/// if (!mlevel)
///     outputradix = outputunderscore = 0;
///
/// if (*s == Nularg)
///     s++;
/// if (!*s) {
///     x.type = MN_INTEGER;
///     x.u.l = 0;
///     return x;
/// }
/// x = mathevall(s, MPREC_TOP, &junk);
/// mtok = xmtok;
/// if (*junk)
///     zerr("bad math expression: illegal character: %c", *junk);
/// return x;
/// ```
///
/// Three divergences in the previous Rust port:
///   1. Missing Nularg-byte skip at c:1489-1490 — `$(())` lexes
///      with a leading Nularg sentinel; without the skip, the math
///      evaluator chokes on the 0xa1 byte instead of evaluating
///      the empty expression as 0.
///   2. Missing empty-input fast path at c:1491-1495 — empty
///      string returned MN_INTEGER 0 in C; Rust port tried to
///      evaluate via mathevall and produced a parse error.
///   3. Missing mtok save/restore around mathevall (c:1483, c:1496) —
///      recursive math calls (e.g. `$((f($((g)))))`) overwrote the
///      outer call's mtok mid-parse.
pub fn matheval(s: &str) -> Result<mnumber, String> {
    // c:1480
    // c:1483 — `int xmtok = mtok;` save.
    let xmtok = M_MTOK.with(|c| c.get()); // c:1483

    // c:1489-1490 — `if (*s == Nularg) s++;`. The 0xa1 sentinel byte
    // can prefix expressions emerging from the parser; skip it.
    let s = if let Some(rest) = s.strip_prefix(Nularg) {
        // c:1489
        rest
    } else {
        s
    };
    // c:1491-1495 — empty expression returns MN_INTEGER 0.
    if s.is_empty() {
        // c:1491
        return Ok(mnumber {
            l: 0,
            d: 0.0,
            type_: MN_INTEGER,
        }); // c:1493-1494
    }
    new(s);
    let result = mathevall();
    // c:1496 — `mtok = xmtok;` restore. Done even on error path.
    M_MTOK.with(|c| c.set(xmtok)); // c:1496
    result
}

/// Port of `mnumber matheval(char *s)` integer-coerce front-end
/// `mod_export zlong mathevali(char *s)` from Src/math.c:1505.
///
/// C body (c:1505-1509):
/// ```c
/// mnumber x = matheval(s);
/// return (x.type & MN_FLOAT) ? (zlong)x.u.d : x.u.l;
/// ```
///
/// Uses bitwise AND against MN_FLOAT — `x.type` is a bitfield holding
/// MN_INTEGER (1), MN_FLOAT (2), MN_UNSET (4). The previous Rust port
/// did `n.type_ == MN_FLOAT` (strict equality) — which misclassifies
/// any result where MN_FLOAT is set alongside another flag (e.g. an
/// uninitialized-then-set result might carry MN_FLOAT|MN_UNSET = 6).
pub fn mathevali(s: &str) -> Result<i64, String> {
    // c:1505
    matheval(s).map(|n|                                                      // c:1506
        if (n.type_ & MN_FLOAT) != 0 { n.d as i64 } else { n.l }) // c:1508
}

/// Port of `zlong mathevalarg(char *s, char **ss)` from `Src/math.c:1514-1539`.
///
/// C body (c:1517-1538):
/// ```c
/// mnumber x;
/// int xmtok = mtok;
/// /* At this entry point we don't allow an empty expression,
///  * whereas we do with matheval(). */
/// if (*s == Nularg)
///     s++;
/// if (!*s) {
///     zerr("bad math expression: empty string");
///     return (zlong)0;
/// }
/// x = mathevall(s, MPREC_ARG, ss);
/// if (mtok == COMMA)
///     (*ss)--;
/// mtok = xmtok;
/// return (x.type & MN_FLOAT) ? (zlong)x.u.d : x.u.l;
/// ```
///
/// Two key differences from `matheval`:
///   1. Empty input is an ERROR (zerr + return 0), NOT silent 0.
///      C's comment: `$array[$ind]` where `$ind` is unset should
///      produce an error, not silently index 0.
///   2. Uses `MPREC_ARG` precedence so the parser stops at the
///      end-of-arg boundary (comma, close-paren) rather than
///      consuming everything as one top-level expression.
///      (Rust mathevall doesn't yet thread the prec_tp arg;
///      flagged for follow-up.)
pub(crate) fn mathevalarg(expr: &str) -> i64 {
    // c:1514
    // c:1517 — `int xmtok = mtok;` save.
    let xmtok = M_MTOK.with(|c| c.get()); // c:1517
                                          // c:1528-1529 — `if (*s == Nularg) s++;`. Skip the parser sentinel.
    let s = if let Some(rest) = expr.strip_prefix(Nularg) {
        // c:1528
        rest
    } else {
        expr
    };
    // c:1530-1532 — empty after Nularg-skip is a HARD error here.
    if s.is_empty() {
        // c:1530
        zerr("bad math expression: empty string"); // c:1531
        return 0; // c:1532
    }
    // c:1534 — `mathevall(s, MPREC_ARG, ss)`. The Rust port doesn't yet
    // thread the prec_tp arg through mathevall (uses C_PREC/Z_PREC toggle
    // only); structural follow-up.
    // c:1538 — `(x.type & MN_FLOAT) ? (zlong)x.u.d : x.u.l`. Bitwise
    // check against MN_FLOAT; strict equality `== MN_FLOAT` misclassifies
    // composite type bitfields (e.g. MN_FLOAT|MN_UNSET).
    let result = matheval(s).map(|n|                                         // c:1538
        if (n.type_ & MN_FLOAT) != 0 { n.d as i64 } else { n.l }
    ).unwrap_or(0);
    // c:1537 — `mtok = xmtok;` restore.
    M_MTOK.with(|c| c.set(xmtok)); // c:1537
    result
}

/// Port of `checkunary(int mtokc, char *mptr)` from `Src/math.c:1548`.
///
/// Two roles. (1) Validate that the just-lexed token (`m_mtok()`)
/// matches the parser's expectation: an operand was wanted but an
/// operator (`OP_*` flags) showed up, or vice versa. Mismatch
/// emits zsh's `bad math expression: <kind> expected at <ctx>`
/// with `<kind>` being `operator` or `operand` and `<ctx>` taken
/// from the input pointer at the start of the bad token. (2)
/// Update `m_unary()` for the next iteration based on `OP_OPF`.
/// WARNING: param names don't match C — Rust=() vs C=(mtokc, mptr)
pub(crate) fn checkunary() {
    // Direct port of zsh math.c checkunary() (line 1548).
    // Two roles:
    //   1. Validate that the just-lexed token (`m_mtok()`)
    //      matches the parser's expectation (operator vs
    //      operand). Mismatch emits zsh's
    //      "bad math expression: <kind> expected at <ctx>"
    //      with `<kind>` = `operator` (errmsg=2) or `operand`
    //      (errmsg=1). zshrs previously only did step 2,
    //      which left e.g. `let "5 5"` and `$((2#1011x))`
    //      silently accepting bogus input.
    //   2. Update `m_unary()` for the next iteration.
    let tp = OP_TYPE[m_mtok() as usize];
    let is_op_token = (tp & (OP_A2 | OP_A2IR | OP_A2IO | OP_E2 | OP_E2IO | OP_OP)) != 0;
    let errmsg = if is_op_token {
        if m_unary() {
            1
        } else {
            0
        }
    } else if !m_unary() {
        2
    } else {
        0
    };
    if errmsg != 0 && !m_error_some() {
        let errtype = if errmsg == 2 { "operator" } else { "operand" };
        // zsh's `mptr` is the input position BEFORE zzlex
        // consumed the bad token. We track the same via
        // `tok_start` which zzlex updates after whitespace
        // skip. Walk forward past whitespace (mirrors zsh's
        // `inblank` skip) so the error context starts at
        // the first visible char.
        let input_owned = m_input_clone();
        let bytes = input_owned.as_bytes();
        let mut start = m_tok_start();
        while start < bytes.len() && matches!(bytes[start], b' ' | b'\t' | b'\n') {
            start += 1;
        }
        // zsh truncates after 10 chars and appends `...` if
        // there's more remaining (the over flag in the C
        // source). Mirror that to keep error messages
        // bounded for long bogus expressions.
        let remaining = m_input_slice_from(start);
        let (ctx, over) = if remaining.chars().count() > 10 {
            let truncated: String = remaining.chars().take(10).collect();
            (truncated, true)
        } else {
            (remaining.to_string(), false)
        };
        if ctx.is_empty() {
            m_error_set(format!(
                "bad math expression: {} expected at end of string",
                errtype
            ));
        } else {
            m_error_set(format!(
                "bad math expression: {} expected at `{}{}'",
                errtype,
                ctx,
                if over { "..." } else { "" }
            ));
        }
    }
    m_unary_set((tp & OP_OPF) == 0);
}

/// Operator-precedence parser - closely follows zsh math.c mathparse()
/// Port of `mathparse(int pc)` from `Src/math.c:1594`.
/// WARNING: param names don't match C — Rust=() vs C=(pc)
pub(crate) fn mathparse(pc: u8) {
    if m_error_some() {
        return;
    }

    m_mtok_set(zzlex());

    // Handle empty input
    if pc == top_prec() && m_mtok() == EOI {
        return;
    }

    checkunary();

    while m_prec()[m_mtok() as usize] <= pc {
        if m_error_some() {
            return;
        }

        match m_mtok() {
            NUM => {
                push(m_yyval(), None);
            }
            ID => {
                let lval = m_yylval_clone();
                if m_noeval() > 0 {
                    push(
                        mnumber {
                            l: 0,
                            d: 0.0,
                            type_: MN_INTEGER,
                        },
                        Some(lval),
                    );
                } else {
                    push(
                        mnumber {
                            l: 0,
                            d: 0.0,
                            type_: MN_UNSET,
                        },
                        Some(lval),
                    );
                }
            }
            CID => {
                let lval = m_yylval_clone();
                let val = if m_noeval() > 0 {
                    mnumber {
                        l: 0,
                        d: 0.0,
                        type_: MN_INTEGER,
                    }
                } else {
                    getcvar(&lval)
                };
                push(val, Some(lval));
            }
            FUNC => {
                let func_call = m_yylval_clone();
                let val = if m_noeval() > 0 {
                    mnumber {
                        l: 0,
                        d: 0.0,
                        type_: MN_INTEGER,
                    }
                } else {
                    callmathfunc(&func_call)
                };
                push(val, None);
            }
            M_INPAR => {
                mathparse(top_prec());
                if m_mtok() != M_OUTPAR {
                    if !m_error_some() {
                        // Match zsh's `bad math expression: ')'
                        // expected` so error diagnostics align.
                        m_error_set("bad math expression: ')' expected".to_string());
                    }
                    return;
                }
            }
            QUEST => {
                // Ternary operator
                if m_stack_is_empty() {
                    m_error_set("bad math expression".to_string());
                    return;
                }
                let mv = m_stack_top_clone().unwrap();
                let cond = get_value(&mv);

                let q = !((cond.type_ == MN_INTEGER && cond.l == 0)
                    || (cond.type_ == MN_FLOAT && cond.d == 0.0)
                    || cond.type_ == MN_UNSET);
                if !q {
                    m_noeval_inc();
                }
                let colon_prec = m_prec()[COLON as usize];
                let stack_before = m_stack_len();
                mathparse(colon_prec - 1);
                if !q {
                    m_noeval_dec();
                }

                if m_mtok() != COLON {
                    if !m_error_some() {
                        // Distinguish whether the inner parse
                        // produced an operand: stack grew →
                        // colon expected; stack same → operand
                        // missing (input ran out at end of
                        // string after `?`).
                        if m_stack_len() > stack_before {
                            m_error_set("bad math expression: ':' expected".to_string());
                        } else {
                            m_error_set(
                                "bad math expression: operand expected at end of string"
                                    .to_string(),
                            );
                        }
                    }
                    return;
                }

                if q {
                    m_noeval_inc();
                }
                let quest_prec = m_prec()[QUEST as usize];
                mathparse(quest_prec);
                if q {
                    m_noeval_dec();
                }

                op(QUEST);
                continue;
            }
            _ => {
                // Binary/unary operator
                let otok = m_mtok();
                let onoeval = m_noeval();
                let tp = OP_TYPE[otok as usize];
                // Orphan binary at start: `let "*"`, `let "*5"`,
                // `let "/"`. zsh keeps its input pointer at the
                // start of the bad operator and emits `operand
                // expected at \`<remaining>'`. zshrs previously
                // collapsed every operand-missing case into "at
                // end of string" which lost the operator
                // location for orphan-at-start expressions.
                let is_binary = (tp & (OP_A2 | OP_A2IR | OP_A2IO | OP_E2 | OP_E2IO)) != 0;
                if m_stack_is_empty() && is_binary {
                    let remaining = m_input_slice_from(m_tok_start());
                    m_error_set(format!(
                        "bad math expression: operand expected at `{}'",
                        remaining
                    ));
                    return;
                }
                if (tp & 0x03) == BOOL {
                    bop(otok);
                }
                let otok_prec = m_prec()[otok as usize];
                // Right-to-left gets same prec, left-to-right gets prec-1
                let adjust = if (tp & 0x01) != RL { 1 } else { 0 };
                mathparse(otok_prec - adjust);
                m_noeval_set(onoeval);
                op(otok);
                continue;
            }
        }

        // After operand (Num, Id, Func, InPar), get next token
        m_mtok_set(zzlex());
        checkunary();
    }
}
/// Zsh precedence table (default)
static Z_PREC: [u8; TOKCOUNT] = [
    1, 137, 2, 2, 2, // InPar OutPar Not Comp PostPlus
    2, 2, 2, 4, 5, // PostMinus UPlus UMinus And Xor
    6, 8, 8, 8, 9, // Or Mul Div Mod Plus
    9, 3, 3, 10, 10, // Minus ShLeft ShRight Les Leq
    10, 10, 11, 11, 12, // Gre Geq Deq Neq DAnd
    13, 13, 14, 15, 16, // DOr DXor Quest Colon Eq
    16, 16, 16, 16, 16, // PlusEq MinusEq MulEq DivEq ModEq
    16, 16, 16, 16, 16, // AndEq XorEq OrEq ShLeftEq ShRightEq
    16, 16, 16, 17, 200, // DAndEq DOrEq DXorEq Comma Eoi
    2, 2, 0, 0, 7, // PrePlus PreMinus Num Id Power
    0, 16, 0, // CId PowerEq Func
];

/// C precedence table (used with C_PRECEDENCES option)
static C_PREC: [u8; TOKCOUNT] = [
    1, 137, 2, 2, 2, 2, 2, 2, 9, 10, 11, 4, 4, 4, 5, 5, 6, 6, 7, 7, 7, 7, 8, 8, 12, 14, 13, 15, 16,
    17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 18, 200, 2, 2, 0, 0, 3, 0, 17, 0,
];

/// Operator type table (matches C math.c type[] array)
static OP_TYPE: [u16; TOKCOUNT] = [
    // InPar, OutPar, Not, Comp, PostPlus
    LR,
    LR | OP_OP | OP_OPF,
    RL,
    RL,
    RL | OP_OP | OP_OPF,
    // PostMinus, UPlus, UMinus, And, Xor
    RL | OP_OP | OP_OPF,
    RL,
    RL,
    LR | OP_A2IO,
    LR | OP_A2IO,
    // Or, Mul, Div, Mod, Plus
    LR | OP_A2IO,
    LR | OP_A2,
    LR | OP_A2,
    LR | OP_A2,
    LR | OP_A2,
    // Minus, ShLeft, ShRight, Les, Leq
    LR | OP_A2,
    LR | OP_A2IO,
    LR | OP_A2IO,
    LR | OP_A2IR,
    LR | OP_A2IR,
    // Gre, Geq, Deq, Neq, DAnd
    LR | OP_A2IR,
    LR | OP_A2IR,
    LR | OP_A2IR,
    LR | OP_A2IR,
    BOOL | OP_A2IO,
    // DOr, DXor, Quest, Colon, Eq
    BOOL | OP_A2IO,
    LR | OP_A2IO,
    RL | OP_OP,
    RL | OP_OP,
    RL | OP_E2,
    // PlusEq, MinusEq, MulEq, DivEq, ModEq
    RL | OP_E2,
    RL | OP_E2,
    RL | OP_E2,
    RL | OP_E2,
    RL | OP_E2,
    // AndEq, XorEq, OrEq, ShLeftEq, ShRightEq
    RL | OP_E2IO,
    RL | OP_E2IO,
    RL | OP_E2IO,
    RL | OP_E2IO,
    RL | OP_E2IO,
    // DAndEq, DOrEq, DXorEq, Comma, Eoi
    BOOL | OP_E2IO,
    BOOL | OP_E2IO,
    RL | OP_A2IO,
    RL | OP_A2,
    RL | OP_OP,
    // PrePlus, PreMinus, Num, Id, Power
    RL,
    RL,
    LR | OP_OPF,
    LR | OP_OPF,
    RL | OP_A2,
    // CId, PowerEq, Func
    LR | OP_OPF,
    RL | OP_E2,
    LR | OP_OPF,
];

// WARNING: NOT IN MATH.C — Rust-only helper. See save_state above.
fn restore_state(saved: xyy_locals) {
    m_input_set(saved.input);
    m_pos_set(saved.pos);
    m_tok_start_set(saved.tok_start);
    m_yyval_set(saved.yyval);
    m_yylval_set(saved.yylval);
    M_STACK.with(|c| *c.borrow_mut() = saved.stack);
    m_mtok_set(saved.mtok);
    m_unary_set(saved.unary);
    m_noeval_set(saved.noeval);
    M_ERROR.with(|c| *c.borrow_mut() = saved.error);
    m_variables_set(saved.variables);
    m_string_variables_set(saved.string_variables);
    m_prec_set(saved.prec);
    m_c_precedences_set(saved.c_precedences);
    m_force_float_set(saved.force_float);
    m_octal_zeroes_set(saved.octal_zeroes);
    M_LASTBASE.with(|c| c.set(saved.lastbase));
}

// MathState struct DELETED — state now lives in M_* thread_locals
// (matching C math.c's module statics + mathevall's xyy* save/restore).

// WARNING: NOT IN MATH.C — Rust-only initializer. C `mathevall()`
// (math.c:367) takes the input as a parameter and seeds the module
// statics inline at function entry; Rust port factors that seeding
// out so call sites can chain `with_*` setters before invoking
// `mathevall()`.
/// Initialize thread_local math state from a fresh input string.
/// Mirrors the entry-side state setup in C `mathevall()` (math.c:367).
pub(crate) fn new(input: &str) {
    m_input_set(input.to_string());
    m_pos_set(0);
    m_tok_start_set(0);
    m_yyval_set(mnumber {
        l: 0,
        d: 0.0,
        type_: MN_INTEGER,
    });
    m_yylval_set(String::new());
    M_STACK.with(|c| {
        c.borrow_mut().clear();
    });
    m_mtok_set(EOI);
    m_unary_set(true);
    m_noeval_set(0);
    m_lastbase_set(-1);
    m_prec_set(&Z_PREC);
    m_c_precedences_set(false);
    m_force_float_set(false);
    m_octal_zeroes_set(false);
    m_variables_set(HashMap::new());
    m_string_variables_set(HashMap::new());
    m_lastval_set(0);
    m_pid_set(std::process::id() as i64);
    m_error_clear();
}

// WARNING: NOT IN MATH.C — Rust-only setter. zsh C reads parameters
// directly from the global param table on demand; the Rust port
// caller seeds an in-memory map up front via this fn.
pub(crate) fn with_variables(vars: HashMap<String, mnumber>) {
    m_variables_set(vars);
}

// WARNING: NOT IN MATH.C — Rust-only setter. Parses each value as
// numeric → `mnumber` if possible, otherwise stores the raw string
// for `getmathparam`'s recursive-eval path (e.g. `a="3+2"; $((a))`).
/// Inject variables from string->string mapping (for shell integration)
pub(crate) fn with_string_variables(vars: &HashMap<String, String>) {
    for (k, v) in vars {
        if let Ok(i) = v.parse::<i64>() {
            m_variables_insert(
                k.clone(),
                mnumber {
                    l: i,
                    d: 0.0,
                    type_: MN_INTEGER,
                },
            );
        } else if let Ok(f) = v.parse::<f64>() {
            m_variables_insert(
                k.clone(),
                mnumber {
                    l: 0,
                    d: f,
                    type_: MN_FLOAT,
                },
            );
        } else if !v.is_empty() {
            // Non-numeric string — keep raw so getmathparam can
            // recursively evaluate it as an arith expression.
            // zsh: `a="3+2"; $((a))` returns 5.
            m_string_variables_insert(k.clone(), v.clone());
        }
    }
}

// WARNING: NOT IN MATH.C — Rust-only accessor. zsh C writes back
// to the global param table during evaluation; ShellExecutor
// integration uses this to harvest the post-eval variables map and
// merge it into its own `variables` table.
/// Extract modified variables as string->string mapping (for shell integration)
pub(crate) fn extract_string_variables() -> HashMap<String, String> {
    M_VARIABLES.with(|c| {
        c.borrow()
            .iter()
            .map(|(k, v)| {
                (
                    k.clone(),
                    match v.type_ {
                        MN_INTEGER => v.l.to_string(),
                        MN_FLOAT => {
                            let f = v.d;
                            if isnan(f) {
                                "NaN".to_string()
                            } else if isinf(f) {
                                if f > 0.0 {
                                    "Inf".to_string()
                                } else {
                                    "-Inf".to_string()
                                }
                            } else {
                                format!("{:.10}", f)
                            }
                        }
                        _ => "0".to_string(),
                    },
                )
            })
            .collect()
    })
}

// WARNING: NOT IN MATH.C — Rust-only setopt mirror. zsh C reads
// the option flag directly from `isset(CPRECEDENCES)` inside
// `mathevall()`; this setter caches the bit so the evaluator
// avoids re-reading the option tree on every token.
pub(crate) fn with_c_precedences(enable: bool) {
    m_c_precedences_set(enable);
    m_prec_set(if enable { &C_PREC } else { &Z_PREC });
}

// WARNING: NOT IN MATH.C — Rust-only setopt mirror for FORCE_FLOAT.
pub(crate) fn with_force_float(enable: bool) {
    m_force_float_set(enable);
}

// WARNING: NOT IN MATH.C — Rust-only setopt mirror for OCTAL_ZEROES.
pub(crate) fn with_octal_zeroes(enable: bool) {
    m_octal_zeroes_set(enable);
}

// WARNING: NOT IN MATH.C — Rust-only setter for `$?` (last command
// status) so the `?`-token in unary position can read it. zsh C
// reads `lastval` directly as a global.
pub(crate) fn with_lastval(val: i32) {
    m_lastval_set(val);
}

// WARNING: NOT IN MATH.C — Rust-only cursor read. C uses `*ptr`
// directly without an fn-shaped wrapper.
pub(crate) fn peek() -> Option<char> {
    m_input_clone()[m_pos()..].chars().next()
}

// WARNING: NOT IN MATH.C — Rust-only cursor advance. C uses
// `*ptr++` directly.
pub(crate) fn advance() -> Option<char> {
    let c = peek()?;
    m_pos_add(c.len_utf8());
    Some(c)
}

// WARNING: NOT IN MATH.C — Rust-only char classifier. C uses
// ctype.h `idigit()` macro directly.
fn is_digit(c: char) -> bool {
    c.is_ascii_digit()
}

// WARNING: NOT IN MATH.C — Rust-only char classifier. C uses
// `iident()` / `isalpha()` macros directly.
fn is_ident_start(c: char) -> bool {
    c.is_ascii_alphabetic() || c == '_'
}

// WARNING: NOT IN MATH.C — Rust-only char classifier. C uses
// `iident()` macro directly.
fn is_ident(c: char) -> bool {
    c.is_ascii_alphanumeric() || c == '_'
}

// WARNING: NOT IN MATH.C — Rust-only stack helper. C inlines
// this inside `pop()` (math.c:931) — its `noget` flag controls
// whether to resolve the deferred Unset+lval read; zshrs splits
// the two paths into separate ported so the resolved-vs-raw choice
// is at the call site.
pub(crate) fn pop_with_lval() -> mathvalue {
    m_stack_pop().unwrap_or_default()
}

// WARNING: NOT IN MATH.C — Rust-only value-resolver. C inlines
// the deferred-variable-read pattern inside `pop()` and `op()`
// (math.c:931, 1154); the Rust port factors it out for `bop`
// and `mathparse` to inspect-without-consuming.
pub(crate) fn get_value(mv: &mathvalue) -> mnumber {
    if (mv.val.type_ == MN_UNSET) {
        if let Some(ref name) = mv.lval {
            return getmathparam(name);
        }
    }
    mv.val
}

// WARNING: NOT IN MATH.C — Rust-only helper. C inlines the
// expression `prec[COMMA] + 1` directly in mathparse() and
// mathevall() everywhere it's needed (math.c:1594, 367).
pub(crate) fn top_prec() -> u8 {
    m_prec()[COMMA as usize] + 1
}

// WARNING: NOT IN MATH.C — Rust-only accessor (note plural — singular
// `getmathparam` IS in math.c:337). zsh C's caller reads the param
// table directly post-eval; this returns a snapshot of the in-memory
// variables map for ShellExecutor integration.
/// Get updated variables after evaluation
pub(crate) fn getmathparams() -> HashMap<String, mnumber> {
    m_variables_clone()
}

// ===========================================================
// Methods moved verbatim from src/ported/vm_helper because their
// C counterpart's source file maps 1:1 to this Rust module.
// Phase: math
// ===========================================================

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

// END moved-from-exec-rs

// ===========================================================
// Free ported moved verbatim from src/ported/vm_helper.
// ===========================================================
// BEGIN moved-from-exec-rs (free ported)
/// Pop argc arguments from the VM stack into a Vec<String>.
///
/// `Value::Array` entries (produced by `${arr[@]}`, glob expansion, brace
/// expansion, etc.) splice into multiple argv-style args — same flattening
/// rule as fusevm's `Op::Exec`. Without this, a builtin like `echo
/// ${arr[@]}` with `arr=(x y z)` would receive a single space-joined arg
/// `"x y z"` instead of three separate args.
/// Subscript-arith parser namespace. Holds the three pre-resolve parsers
/// `eval_arith_expr` runs against an expression before substituting array
/// references — the C source's `mathexpr()` (Src/math.c) inlines this work
/// inside the lexer, but Rust splits it out so the assignment-target arms
/// don't get confused with read sites.
// WARNING: NOT IN MATH.C — Rust-only string parser. C `setmathvar`
// (math.c:972) walks the lvalue pointer left in place by zzlex,
// so subscripted compound assigns fall out of the lexer for free.
// zshrs sees `((a[i]+=v))` as raw text and must split it before
// pre_resolve_array_subscripts substitutes the read value in place.
#[inline]
/// Detect `name[idx]=rhs` (or `name[idx]+=rhs`, etc.) at the start of
/// an arith expression. Returns (name, idx_expr, rhs). Used by
/// `eval_arith_expr` to handle `((a[i]=expr))` — the regular pre-
/// resolve pass would substitute a[i] with its current value first,
/// turning the expression into `0=42` which is invalid.
/// Parse `name[idx]OP rhs?` where OP is `++`, `--`, `+=`, `-=`, etc.
/// Returns (name, idx_expr, op, rhs). For `++`/`--`, rhs is empty.
pub(crate) fn parse_compound(expr: &str) -> Option<(String, String, String, String)> {
    let trimmed = expr.trim();
    let bytes = trimmed.as_bytes();
    if bytes.is_empty() || !(bytes[0] == b'_' || bytes[0].is_ascii_alphabetic()) {
        return None;
    }
    let mut i = 1;
    while i < bytes.len() && (bytes[i] == b'_' || bytes[i].is_ascii_alphanumeric()) {
        i += 1;
    }
    let name = trimmed[..i].to_string();
    if i >= bytes.len() || bytes[i] != b'[' {
        return None;
    }
    let idx_start = i + 1;
    let mut depth = 1;
    let mut j = idx_start;
    while j < bytes.len() && depth > 0 {
        match bytes[j] {
            b'[' => depth += 1,
            b']' => {
                depth -= 1;
                if depth == 0 {
                    break;
                }
            }
            _ => {}
        }
        j += 1;
    }
    if j >= bytes.len() {
        return None;
    }
    let idx_expr = trimmed[idx_start..j].to_string();
    let mut k = j + 1;
    while k < bytes.len() && bytes[k].is_ascii_whitespace() {
        k += 1;
    }
    if k >= bytes.len() {
        return None;
    }
    let rest = &bytes[k..];
    // Try 3-char operators first (`<<=`, `>>=`, `**=`), then 2-char
    // (`++`, `--`, `+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `|=`, `^=`).
    let (op, op_len) = match rest {
        [b'<', b'<', b'=', ..] => ("<<=", 3),
        [b'>', b'>', b'=', ..] => (">>=", 3),
        [b'*', b'*', b'=', ..] => ("**=", 3),
        [b'+', b'+', ..] => ("++", 2),
        [b'-', b'-', ..] => ("--", 2),
        [b'+', b'=', ..] => ("+=", 2),
        [b'-', b'=', ..] => ("-=", 2),
        [b'*', b'=', ..] => ("*=", 2),
        [b'/', b'=', ..] => ("/=", 2),
        [b'%', b'=', ..] => ("%=", 2),
        [b'&', b'=', ..] => ("&=", 2),
        [b'|', b'=', ..] => ("|=", 2),
        [b'^', b'=', ..] => ("^=", 2),
        _ => return None,
    };
    let rhs = trimmed[k + op_len..].trim().to_string();
    // For `++` / `--`, the rhs MUST be empty (anything else would be
    // a parse error). For `+=` etc., rhs is the value expression.
    if (op == "++" || op == "--") && !rhs.is_empty() {
        return None;
    }
    Some((name, idx_expr, op.to_string(), rhs))
}
// WARNING: NOT IN MATH.C — Rust-only string parser. C handles
// `++NAME[IDX]` via the lexer leaving the lvalue pointer set; the
// Rust port pre-parses the text. See parse_compound above.
/// Pre-increment/decrement on subscript: `++NAME[IDX]` / `--NAME[IDX]`.
/// Returns (name, idx_expr, op) where op is "++" or "--".
pub(crate) fn parse_pre_inc(expr: &str) -> Option<(String, String, String)> {
    let trimmed = expr.trim();
    let (after_op, pre_op) = if let Some(s) = trimmed.strip_prefix("++") {
        (s, "++")
    } else if let Some(s) = trimmed.strip_prefix("--") {
        (s, "--")
    } else {
        return None;
    };
    let after_op = after_op.trim_start();
    let bytes = after_op.as_bytes();
    if bytes.is_empty() || !(bytes[0] == b'_' || bytes[0].is_ascii_alphabetic()) {
        return None;
    }
    let mut i = 1;
    while i < bytes.len() && (bytes[i] == b'_' || bytes[i].is_ascii_alphanumeric()) {
        i += 1;
    }
    let name = after_op[..i].to_string();
    if i >= bytes.len() || bytes[i] != b'[' {
        return None;
    }
    let idx_start = i + 1;
    let mut depth = 1;
    let mut j = idx_start;
    while j < bytes.len() && depth > 0 {
        match bytes[j] {
            b'[' => depth += 1,
            b']' => {
                depth -= 1;
                if depth == 0 {
                    break;
                }
            }
            _ => {}
        }
        j += 1;
    }
    if j >= bytes.len() {
        return None;
    }
    let idx_expr = after_op[idx_start..j].to_string();
    // After ], must be end of input (or whitespace).
    let mut k = j + 1;
    while k < bytes.len() && bytes[k].is_ascii_whitespace() {
        k += 1;
    }
    if k != bytes.len() {
        return None;
    }
    Some((name, idx_expr, pre_op.to_string()))
}
// WARNING: NOT IN MATH.C — Rust-only string parser for `NAME[IDX]=v`.
// See parse_compound above for the rationale.
pub(crate) fn parse_assign(expr: &str) -> Option<(String, String, String)> {
    let trimmed = expr.trim();
    let bytes = trimmed.as_bytes();
    if bytes.is_empty() || !(bytes[0] == b'_' || bytes[0].is_ascii_alphabetic()) {
        return None;
    }
    let mut i = 1;
    while i < bytes.len() && (bytes[i] == b'_' || bytes[i].is_ascii_alphanumeric()) {
        i += 1;
    }
    let name = trimmed[..i].to_string();
    if i >= bytes.len() || bytes[i] != b'[' {
        return None;
    }
    let idx_start = i + 1;
    let mut depth = 1;
    let mut j = idx_start;
    while j < bytes.len() && depth > 0 {
        match bytes[j] {
            b'[' => depth += 1,
            b']' => {
                depth -= 1;
                if depth == 0 {
                    break;
                }
            }
            _ => {}
        }
        j += 1;
    }
    if j >= bytes.len() {
        return None;
    }
    let idx_expr = trimmed[idx_start..j].to_string();
    // Skip ]
    let mut k = j + 1;
    while k < bytes.len() && bytes[k].is_ascii_whitespace() {
        k += 1;
    }
    if k >= bytes.len() || bytes[k] != b'=' {
        return None;
    }
    // Reject `==` and `=~` (comparison/regex, not assignment).
    if k + 1 < bytes.len() && (bytes[k + 1] == b'=' || bytes[k + 1] == b'~') {
        return None;
    }
    let rhs = trimmed[k + 1..].trim().to_string();
    Some((name, idx_expr, rhs))
}

// END moved-from-exec-rs (free ported)

// ===========================================================
// Numeric formatting helpers moved from src/ported/vm_helper.
// Mirror Src/math.c / Src/utils.c base+digit-grouping logic.
// ===========================================================

// WARNING: NOT IN MATH.C — `convbase` lives in `Src/params.c:5632`
// (called from math.c:1089). This file holds a duplicate that
// predates the params.rs port; canonical home is
// `convbase`. This entry is drift pending
// cleanup; do not add new callers — use `convbase`.
/// Format an integer in the given base (2-36) using zsh's
// `convbase` lives in params.rs (matching C: defined in params.c:5632
// as a 1-line delegation to `convbase_ptr` at params.c:5586). The
// math.rs entry that used to duplicate it is removed; callers should
// import `convbase` directly.

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

    /// `setmathvar` writes through to paramtab via `setnparam`.
    /// After the call, `getsparam(name)` should return the value.
    #[test]
    fn setmathvar_writes_to_paramtab() {
        let _g = crate::test_util::global_state_lock();
        // setnparam early-returns under `unset(EXECOPT)`. Enable it
        // (default in interactive shells; tests run with all opts
        // unset by default).
        opt_state_set("exec", true);
        // Sanity: a direct setiparam call should also work.
        unsetparam("mvar1_baseline");
        crate::ported::params::setiparam("mvar1_baseline", 42);
        let baseline = getsparam("mvar1_baseline");
        assert_eq!(
            baseline.as_deref(),
            Some("42"),
            "baseline setiparam path; got {:?}",
            baseline
        );
        unsetparam("mvar1_baseline");

        unsetparam("mvar1");
        let v = mnumber {
            l: 42,
            d: 0.0,
            type_: MN_INTEGER,
        };
        let returned = setmathvar("mvar1", v);
        assert_eq!(returned.l, 42);
        let stored = getsparam("mvar1");
        assert_eq!(
            stored.as_deref(),
            Some("42"),
            "setmathvar should write through; got {:?}",
            stored
        );
        unsetparam("mvar1");
        opt_state_set("exec", false);
    }

    /// `setmathvar` with empty name emits zerr and returns 0.
    #[test]
    fn setmathvar_empty_name_returns_zero() {
        let _g = crate::test_util::global_state_lock();
        let v = mnumber {
            l: 99,
            d: 0.0,
            type_: MN_INTEGER,
        };
        let returned = setmathvar("", v);
        assert_eq!(returned.l, 0);
        assert_eq!(returned.type_, MN_INTEGER);
    }

    /// End-to-end round trip: `setmathvar` writes through paramtab;
    /// `getmathparam` reads back the same value via `getsparam`. Pins
    /// the full math ↔ paramtab integration that the recent setmathvar
    /// and getsparam-PM_INTEGER fixes enable together.
    #[test]
    fn setmathvar_getmathparam_roundtrip() {
        let _g = crate::test_util::global_state_lock();
        opt_state_set("exec", true);
        unsetparam("rt_int");
        unsetparam("rt_float");

        // Integer roundtrip
        let n_in = mnumber {
            l: 123,
            d: 0.0,
            type_: MN_INTEGER,
        };
        setmathvar("rt_int", n_in);
        let n_out = getmathparam("rt_int");
        assert_eq!(n_out.type_, MN_INTEGER);
        assert_eq!(n_out.l, 123);

        // Float roundtrip
        let f_in = mnumber {
            l: 0,
            d: 3.14,
            type_: MN_FLOAT,
        };
        setmathvar("rt_float", f_in);
        let f_out = getmathparam("rt_float");
        // Stored as paramtab PM_FFLOAT (per setnparam c:3687); read
        // back as MN_FLOAT.
        assert_eq!(f_out.type_, MN_FLOAT);
        assert!(
            (f_out.d - 3.14).abs() < 1e-9,
            "expected ~3.14, got {}",
            f_out.d
        );

        unsetparam("rt_int");
        unsetparam("rt_float");
        opt_state_set("exec", false);
    }

    /// `setmathvar` with subscript splits at `[` and writes to the
    /// base name (subscript handling is upstream).
    #[test]
    fn setmathvar_subscript_writes_to_base_name() {
        let _g = crate::test_util::global_state_lock();
        opt_state_set("exec", true);
        unsetparam("mvar2");
        let v = mnumber {
            l: 7,
            d: 0.0,
            type_: MN_INTEGER,
        };
        setmathvar("mvar2[5]", v);
        let stored = getsparam("mvar2");
        // The base "mvar2" got the value; subscript element handling
        // is upstream so we just confirm the param was created.
        assert!(stored.is_some());
        unsetparam("mvar2");
        opt_state_set("exec", false);
    }

    /// `setmathvar` MUST short-circuit when `noeval` is set (c:1002-1003).
    /// Used by the unused branch of a math ternary: `(( cond ? a=1 : b=2 ))`
    /// evaluates only ONE side; the other side runs with noeval=1 to
    /// type-check without side effects. A regression that ignores
    /// noeval would assign BOTH sides, corrupting the unselected
    /// variable on every conditional expression.
    ///
    /// Pin: with noeval set, assigning to "ne_var" must NOT create
    /// the param. The return value still equals the input (so the
    /// arithmetic stack sees a sane value); paramtab stays unchanged.
    #[test]
    fn setmathvar_noeval_skips_paramtab_write() {
        let _g = crate::test_util::global_state_lock();
        opt_state_set("exec", true);
        unsetparam("ne_var");

        // Set the math-local noeval counter.
        M_NOEVAL.with(|n| n.set(1));

        let v = mnumber {
            l: 42,
            d: 0.0,
            type_: MN_INTEGER,
        };
        let ret = setmathvar("ne_var", v);
        assert_eq!(
            ret.l, 42,
            "c:1003 — `return v` so the stack still sees the value"
        );
        // The paramtab MUST NOT have a new entry.
        assert!(
            getsparam("ne_var").is_none(),
            "c:1002-1003 — noeval suppresses the paramtab write"
        );

        // Restore noeval so subsequent tests aren't affected.
        M_NOEVAL.with(|n| n.set(0));
        opt_state_set("exec", false);
    }

    /// `setmathvar` returns a value RE-TYPED to match the destination
    /// param's type (C c:1014-1027). Assigning a FLOAT to a PM_INTEGER
    /// param must return an integer-typed mnumber with the float
    /// truncated. This matches C's "assignment returns the typed
    /// value" contract — used by chained assignment expressions like
    /// `(( a = b = 3.7 ))` where `a`'s type drives the cascade.
    #[test]
    fn setmathvar_float_into_integer_coerces_return_type() {
        let _g = crate::test_util::global_state_lock();
        opt_state_set("exec", true);
        unsetparam("intvar");
        // Pre-create as PM_INTEGER so the type is fixed.
        crate::ported::params::setiparam("intvar", 0);

        // Assign a float; expect integer return with truncated value.
        let v = mnumber {
            l: 0,
            d: 3.7,
            type_: MN_FLOAT,
        };
        let ret = setmathvar("intvar", v);
        assert_eq!(
            ret.type_, MN_INTEGER,
            "c:1016-1020 — PM_INTEGER target must return MN_INTEGER"
        );
        assert_eq!(
            ret.l, 3,
            "c:1018 — float→int truncates (3.7 → 3, not rounded)"
        );

        unsetparam("intvar");
        opt_state_set("exec", false);
    }

    /// Pin `mathevalarg` empty-string error path per c:1530-1532.
    /// Unlike `matheval` which returns MN_INTEGER 0 on empty, this
    /// entry point treats empty as a HARD error (emits zerr and
    /// returns 0). Used by callers like `$array[$ind]` where unset
    /// `$ind` should produce a diagnostic rather than silently index 0.
    #[test]
    fn mathevalarg_empty_emits_error_and_returns_zero() {
        let _g = crate::test_util::global_state_lock();
        // Empty input → returns 0 with error message emitted.
        let r = mathevalarg("");
        assert_eq!(r, 0, "c:1532 — empty input returns 0");

        // Nularg-only → also empty after skip, returns 0.
        let nularg_only: String = "\u{a1}".to_string();
        let r = mathevalarg(&nularg_only);
        assert_eq!(
            r, 0,
            "c:1528-1532 — Nularg-only is empty after skip, returns 0"
        );

        // Valid expression → real evaluation.
        let r = mathevalarg("1 + 2");
        assert_eq!(r, 3, "c:1534 — non-empty expression evaluates normally");

        // Nularg-prefixed expression → skipped, then evaluated.
        let nularg_plus: String = "\u{a1}5 * 5".to_string();
        let r = mathevalarg(&nularg_plus);
        assert_eq!(
            r, 25,
            "c:1529 — Nularg skipped, then `5 * 5` evaluates to 25"
        );
    }

    /// Pin `matheval` empty + Nularg fast paths per c:1489-1495.
    /// Empty input MUST return MN_INTEGER 0 without invoking the
    /// parser; the Nularg sentinel (0xa1) byte at the start of the
    /// input MUST be skipped before the empty check.
    #[test]
    fn matheval_empty_input_returns_zero_int() {
        let _g = crate::test_util::global_state_lock();
        // Empty string → MN_INTEGER 0 (c:1491-1494).
        let r = matheval("").expect("empty string must return 0, not error");
        assert_eq!(
            r.type_, MN_INTEGER,
            "c:1493 — empty input returns MN_INTEGER"
        );
        assert_eq!(r.l, 0, "c:1494 — empty input value is 0");

        // Nularg-only string → also returns 0 (c:1489-1494).
        let nularg_only: String = "\u{a1}".to_string();
        let r = matheval(&nularg_only)
            .expect("Nularg-only must return 0 (treated as empty after skip)");
        assert_eq!(
            r.type_, MN_INTEGER,
            "c:1489-1493 — Nularg-only input treated as empty → MN_INTEGER"
        );
        assert_eq!(r.l, 0, "c:1494 — Nularg-only input value is 0");

        // Nularg + expression → evaluates the expression (c:1490 skip).
        let nularg_plus: String = "\u{a1}1 + 2".to_string();
        let r =
            matheval(&nularg_plus).expect("Nularg prefix must be skipped and expression evaluated");
        let v = if r.type_ == MN_FLOAT { r.d as i64 } else { r.l };
        assert_eq!(v, 3, "c:1490 — Nularg skipped, then `1 + 2` evaluates to 3");
    }

    #[test]
    fn test_basic_arithmetic() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("1 + 2").unwrap(), 3);
        assert_eq!(mathevali("10 - 3").unwrap(), 7);
        assert_eq!(mathevali("4 * 5").unwrap(), 20);
        assert_eq!(mathevali("20 / 4").unwrap(), 5);
        assert_eq!(mathevali("17 % 5").unwrap(), 2);
    }

    #[test]
    fn test_precedence() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("2 + 3 * 4").unwrap(), 14);
        assert_eq!(mathevali("(2 + 3) * 4").unwrap(), 20);
        assert_eq!(mathevali("2 ** 3 ** 2").unwrap(), 512); // Right associative
    }

    #[test]
    fn test_comparison() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("5 > 3").unwrap(), 1);
        assert_eq!(mathevali("5 < 3").unwrap(), 0);
        assert_eq!(mathevali("5 == 5").unwrap(), 1);
        assert_eq!(mathevali("5 != 3").unwrap(), 1);
        assert_eq!(mathevali("5 >= 5").unwrap(), 1);
        assert_eq!(mathevali("5 <= 5").unwrap(), 1);
    }

    #[test]
    fn test_logical() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("1 && 1").unwrap(), 1);
        assert_eq!(mathevali("1 && 0").unwrap(), 0);
        assert_eq!(mathevali("1 || 0").unwrap(), 1);
        assert_eq!(mathevali("0 || 0").unwrap(), 0);
        assert_eq!(mathevali("!0").unwrap(), 1);
        assert_eq!(mathevali("!1").unwrap(), 0);
    }

    #[test]
    fn test_bitwise() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("5 & 3").unwrap(), 1);
        assert_eq!(mathevali("5 | 3").unwrap(), 7);
        assert_eq!(mathevali("5 ^ 3").unwrap(), 6);
        assert_eq!(mathevali("~0").unwrap(), -1);
        assert_eq!(mathevali("1 << 4").unwrap(), 16);
        assert_eq!(mathevali("16 >> 2").unwrap(), 4);
    }

    #[test]
    fn test_ternary() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("1 ? 10 : 20").unwrap(), 10);
        assert_eq!(mathevali("0 ? 10 : 20").unwrap(), 20);
        assert_eq!(mathevali("(5 > 3) ? 100 : 200").unwrap(), 100);
    }

    #[test]
    fn test_power() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("2 ** 10").unwrap(), 1024);
        assert_eq!(mathevali("3 ** 3").unwrap(), 27);
        assert!(
            (matheval("2.0 ** 0.5")
                .map(|n| (if n.type_ == MN_FLOAT { n.d } else { n.l as f64 }))
                .unwrap()
                - std::f64::consts::SQRT_2)
                .abs()
                < 0.0001
        );
    }

    #[test]
    fn test_float() {
        let _g = crate::test_util::global_state_lock();
        assert!(
            (matheval("3.14 + 0.01")
                .map(|n| (if n.type_ == MN_FLOAT { n.d } else { n.l as f64 }))
                .unwrap()
                - 3.15)
                .abs()
                < 0.0001
        );
        assert!(
            (matheval("1.5 * 2.0")
                .map(|n| (if n.type_ == MN_FLOAT { n.d } else { n.l as f64 }))
                .unwrap()
                - 3.0)
                .abs()
                < 0.0001
        );
    }

    #[test]
    fn test_unary() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("-5").unwrap(), -5);
        assert_eq!(mathevali("- -5").unwrap(), 5); // space needed to avoid --
        assert_eq!(mathevali("+5").unwrap(), 5);
        assert_eq!(mathevali("-(-5)").unwrap(), 5);
    }

    #[test]
    fn test_base() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("0xFF").unwrap(), 255);
        assert_eq!(mathevali("0b1010").unwrap(), 10);
        assert_eq!(mathevali("16#FF").unwrap(), 255);
        assert_eq!(mathevali("2#1010").unwrap(), 10);
        assert_eq!(mathevali("[16]FF").unwrap(), 255);
    }

    #[test]
    fn test_variables() {
        let _g = crate::test_util::global_state_lock();
        let mut vars = HashMap::new();
        vars.insert(
            "x".to_string(),
            mnumber {
                l: 10,
                d: 0.0,
                type_: MN_INTEGER,
            },
        );
        vars.insert(
            "y".to_string(),
            mnumber {
                l: 20,
                d: 0.0,
                type_: MN_INTEGER,
            },
        );

        new("x + y");
        with_variables(vars);
        assert_eq!(
            ({
                let __m = mathevall().unwrap();
                if __m.type_ == MN_FLOAT {
                    __m.d as i64
                } else {
                    __m.l
                }
            }),
            30
        );
    }

    #[test]
    fn test_assignment() {
        let _g = crate::test_util::global_state_lock();
        new("x = 5");
        mathevall().unwrap();
        assert_eq!(
            ({
                let __m = m_variables_get("x").unwrap();
                if __m.type_ == MN_FLOAT {
                    __m.d as i64
                } else {
                    __m.l
                }
            }),
            5
        );

        new("x = 5, x += 3");
        let result = mathevall().unwrap();
        assert_eq!(
            (if result.type_ == MN_FLOAT {
                result.d as i64
            } else {
                result.l
            }),
            8
        );
    }

    #[test]
    fn test_increment() {
        let _g = crate::test_util::global_state_lock();
        let mut vars = HashMap::new();
        vars.insert(
            "x".to_string(),
            mnumber {
                l: 5,
                d: 0.0,
                type_: MN_INTEGER,
            },
        );

        new("++x");
        with_variables(vars.clone());
        assert_eq!(
            ({
                let __m = mathevall().unwrap();
                if __m.type_ == MN_FLOAT {
                    __m.d as i64
                } else {
                    __m.l
                }
            }),
            6
        );
        assert_eq!(
            ({
                let __m = m_variables_get("x").unwrap();
                if __m.type_ == MN_FLOAT {
                    __m.d as i64
                } else {
                    __m.l
                }
            }),
            6
        );

        new("x++");
        with_variables(vars.clone());
        assert_eq!(
            ({
                let __m = mathevall().unwrap();
                if __m.type_ == MN_FLOAT {
                    __m.d as i64
                } else {
                    __m.l
                }
            }),
            5
        );
        assert_eq!(
            ({
                let __m = m_variables_get("x").unwrap();
                if __m.type_ == MN_FLOAT {
                    __m.d as i64
                } else {
                    __m.l
                }
            }),
            6
        );
    }

    #[test]
    fn test_functions() {
        let _g = crate::test_util::global_state_lock();
        // c:Src/math.c:1037 — `callmathfunc` requires `zsh/mathfunc`
        // to be in the loaded-modules table. zsh -fc returns
        // "unknown function: sqrt" without `zmodload zsh/mathfunc`
        // — the same gating now applies in zshrs. Boot the module
        // here so the unit test exercises the math-function bodies
        // not the missing-module guard.
        crate::ported::module::MODULESTAB
            .lock()
            .unwrap()
            .load_module("zsh/mathfunc");
        assert!(
            (matheval("sqrt(4)")
                .map(|n| (if n.type_ == MN_FLOAT { n.d } else { n.l as f64 }))
                .unwrap()
                - 2.0)
                .abs()
                < 0.0001
        );
        assert!(
            (matheval("sin(0)")
                .map(|n| (if n.type_ == MN_FLOAT { n.d } else { n.l as f64 }))
                .unwrap())
            .abs()
                < 0.0001
        );
        assert!(
            (matheval("cos(0)")
                .map(|n| (if n.type_ == MN_FLOAT { n.d } else { n.l as f64 }))
                .unwrap()
                - 1.0)
                .abs()
                < 0.0001
        );
        assert!(
            (matheval("abs(-5)")
                .map(|n| (if n.type_ == MN_FLOAT { n.d } else { n.l as f64 }))
                .unwrap()
                - 5.0)
                .abs()
                < 0.0001
        );
        assert!(
            (matheval("floor(3.7)")
                .map(|n| (if n.type_ == MN_FLOAT { n.d } else { n.l as f64 }))
                .unwrap()
                - 3.0)
                .abs()
                < 0.0001
        );
        assert!(
            (matheval("ceil(3.2)")
                .map(|n| (if n.type_ == MN_FLOAT { n.d } else { n.l as f64 }))
                .unwrap()
                - 4.0)
                .abs()
                < 0.0001
        );
    }

    #[test]
    fn test_special_values() {
        let _g = crate::test_util::global_state_lock();
        assert!(matheval("Inf")
            .map(|n| (if n.type_ == MN_FLOAT { n.d } else { n.l as f64 }))
            .unwrap()
            .is_infinite());
        assert!(matheval("NaN")
            .map(|n| (if n.type_ == MN_FLOAT { n.d } else { n.l as f64 }))
            .unwrap()
            .is_nan());
    }

    #[test]
    fn test_errors() {
        let _g = crate::test_util::global_state_lock();
        assert!(matheval("1 / 0").is_err());
        assert!(matheval("1 +").is_err());
        // Empty arith expression is a parse error in zsh:
        //   $ zsh -c '(( ))'; echo $?   →   1
        // zsh aborts with `bad math expression: empty parentheses`.
        assert!(matheval("()").is_err());
    }

    #[test]
    fn test_underscore_in_numbers() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("1_000_000").unwrap(), 1000000);
        assert_eq!(mathevali("0xFF_FF").unwrap(), 65535);
    }

    #[test]
    fn test_comma_operator() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("1, 2, 3").unwrap(), 3);
        assert_eq!(mathevali("(x = 1, y = 2, x + y)").unwrap(), 3);
    }

    /// c:1505 — integer divide-by-zero is a runtime error in `$(( ))`.
    /// A regression returning 0 silently masks programmer errors.
    #[test]
    fn mathevali_divide_by_zero_errors() {
        let _g = crate::test_util::global_state_lock();
        assert!(mathevali("1/0").is_err());
        assert!(mathevali("5/(2-2)").is_err());
    }

    /// c:1505-1508 — `mathevali` returns `(x.type & MN_FLOAT) ?
    /// (zlong)x.u.d : x.u.l`. A float result rounded toward zero;
    /// MN_INTEGER returns x.u.l unchanged. Regression target: the
    /// previous Rust port used strict equality `== MN_FLOAT` which
    /// misclassifies any composite MN_FLOAT|MN_X bitfield.
    #[test]
    fn mathevali_truncates_float_via_bitmask_not_strict_eq() {
        let _g = crate::test_util::global_state_lock();
        // Float expression → truncated toward zero (3.7 → 3, -3.7 → -3).
        assert_eq!(mathevali("3.7").unwrap(), 3);
        assert_eq!(mathevali("-3.7").unwrap(), -3);
        // Pure integer expression → MN_INTEGER path, no truncation.
        assert_eq!(mathevali("42").unwrap(), 42);
    }

    /// c:1480 — mod-by-zero is also an error (matches POSIX).
    #[test]
    fn mathevali_mod_by_zero_errors() {
        let _g = crate::test_util::global_state_lock();
        assert!(mathevali("5 % 0").is_err());
    }

    /// c:1505 — operator precedence: `*` binds tighter than `+`.
    /// Regression flipping this would silently break every
    /// `$(( a + b * c ))` users compute.
    #[test]
    fn mathevali_respects_multiplicative_over_additive_precedence() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("1 + 2 * 3").unwrap(), 7);
        assert_eq!(mathevali("(1 + 2) * 3").unwrap(), 9);
        assert_eq!(mathevali("10 - 2 * 3").unwrap(), 4);
    }

    /// c:1505 — bitshift `<<` `>>` from `$(( ))` grammar. Regression
    /// dropping them breaks any hex-mask / bit-pack computation.
    #[test]
    fn mathevali_bitshift_operators() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("1 << 4").unwrap(), 16);
        assert_eq!(mathevali("256 >> 3").unwrap(), 32);
    }

    /// c:1505 — `&&` short-circuits on zero LHS. Regression that
    /// evaluates the RHS would surface side-effects (or divide-
    /// by-zero) the user expected NOT to fire.
    #[test]
    fn mathevali_logical_and_short_circuits_on_zero_lhs() {
        let _g = crate::test_util::global_state_lock();
        // If RHS evaluated, `1/0` would error. Short-circuit must skip.
        assert_eq!(mathevali("0 && 1/0").unwrap(), 0);
    }

    /// c:1505 — `||` short-circuits on non-zero LHS. Same rationale.
    #[test]
    fn mathevali_logical_or_short_circuits_on_nonzero_lhs() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("1 || 1/0").unwrap(), 1);
    }

    /// c:1505 — ternary `cond ? a : b` evaluates ONLY the selected
    /// branch. Regression that evaluates both surfaces side-effects
    /// in the unused branch.
    #[test]
    fn mathevali_ternary_evaluates_only_selected_branch() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("1 ? 42 : 1/0").unwrap(), 42);
        assert_eq!(mathevali("0 ? 1/0 : 42").unwrap(), 42);
    }

    /// `Src/math.c:467-490` — `$(( ))` integer arithmetic supports
    /// hex (`0x`/`0X`), binary (`0b`/`0B`). Octal-via-leading-zero
    /// (`0777`) is OPT-IN behind the OCTALZEROES option — by default
    /// `0777` parses as decimal 777 (matches C's c:489 conditional).
    /// Pin both the hex/binary path AND the default-decimal behavior
    /// for leading-zero.
    #[test]
    fn mathevali_parses_hex_and_binary_literals() {
        let _g = crate::test_util::global_state_lock();
        // Hex literals at c:471 (lowchar 'x').
        assert_eq!(mathevali("0xff").unwrap(), 255);
        assert_eq!(mathevali("0x10").unwrap(), 16);
        assert_eq!(mathevali("0xff + 1").unwrap(), 256);
        // Binary literals at c:471 (lowchar 'b').
        assert_eq!(mathevali("0b1010").unwrap(), 10);
        assert_eq!(mathevali("0b11111111").unwrap(), 255);
        // Default-OCTALZEROES-off: `0777` is decimal 777, NOT octal 511.
        assert_eq!(
            mathevali("0777").unwrap(),
            777,
            "c:489 — leading-zero parses as decimal when OCTALZEROES off"
        );
    }

    /// c:1505 — bitwise AND/OR/XOR. Each operator has its own
    /// precedence tier between shifts and logical ops. Regression
    /// flipping precedence between `&` and `|` would break `$(( a &
    /// b | c ))` (must be `(a&b) | c`, not `a & (b|c)`).
    #[test]
    fn mathevali_bitwise_operators_and_or_xor() {
        let _g = crate::test_util::global_state_lock();
        // Boolean truth-table cases.
        assert_eq!(mathevali("12 & 10").unwrap(), 8, "1100 & 1010 = 1000");
        assert_eq!(mathevali("12 | 10").unwrap(), 14, "1100 | 1010 = 1110");
        assert_eq!(mathevali("12 ^ 10").unwrap(), 6, "1100 ^ 1010 = 0110");
        // Precedence: `&` > `^` > `|`, so `a & b | c` == `(a&b) | c`.
        assert_eq!(
            mathevali("12 & 10 | 1").unwrap(),
            9,
            "c:1505 — & binds tighter than | : (12 & 10) | 1 = 8 | 1 = 9"
        );
    }

    /// c:1505 — comparison ops produce 0 or 1 (Boolean semantics).
    /// Pin all six relational ops.
    #[test]
    fn mathevali_comparison_operators_return_zero_or_one() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("1 < 2").unwrap(), 1);
        assert_eq!(mathevali("2 < 1").unwrap(), 0);
        assert_eq!(mathevali("2 > 1").unwrap(), 1);
        assert_eq!(mathevali("1 > 2").unwrap(), 0);
        assert_eq!(mathevali("2 <= 2").unwrap(), 1);
        assert_eq!(mathevali("2 >= 2").unwrap(), 1);
        assert_eq!(mathevali("2 == 2").unwrap(), 1);
        assert_eq!(mathevali("2 != 2").unwrap(), 0);
    }

    /// c:1505 — unary minus and bitwise NOT. The C parser must
    /// distinguish `1 - 2` (binary) from `1 + -2` (unary).
    #[test]
    fn mathevali_unary_minus_and_bitwise_not() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("-5").unwrap(), -5);
        assert_eq!(mathevali("-(2 + 3)").unwrap(), -5);
        assert_eq!(mathevali("1 + -2").unwrap(), -1);
        // Bitwise NOT (~).
        assert_eq!(mathevali("~0").unwrap(), -1, "two's-complement: ~0 = -1");
        assert_eq!(mathevali("~5").unwrap(), -6);
    }

    /// c:1505 — logical NOT operator `!`. Maps 0 → 1, anything-else → 0.
    #[test]
    fn mathevali_logical_not() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("!0").unwrap(), 1);
        assert_eq!(mathevali("!1").unwrap(), 0);
        assert_eq!(mathevali("!42").unwrap(), 0);
        // Double-NOT normalises to 0/1.
        assert_eq!(mathevali("!!42").unwrap(), 1);
        assert_eq!(mathevali("!!0").unwrap(), 0);
    }

    /// `Src/math.c:109-161` — math token IDs are `#define`d as a
    /// densely-packed integer ladder used as indices into the precedence
    /// (`Z_PREC` / `C_PREC`) and type (`OP_TYPE`) tables. Position is
    /// load-bearing: shifting any value silently mis-routes every math
    /// expression at runtime. Pin every value individually so a reorder
    /// or off-by-one fails this test. QUEST=27 and COMMA=43 specifically
    /// were previously typed in Title-case (`Quest`/`Comma`) violating
    /// the C-source casing rule.
    #[test]
    fn math_token_ids_match_c_source_position_for_position() {
        let _g = crate::test_util::global_state_lock();
        let table = [
            ("M_INPAR", M_INPAR, 0),
            ("M_OUTPAR", M_OUTPAR, 1),
            ("NOT", NOT, 2),
            ("COMP", COMP, 3),
            ("POSTPLUS", POSTPLUS, 4),
            ("POSTMINUS", POSTMINUS, 5),
            ("UPLUS", UPLUS, 6),
            ("UMINUS", UMINUS, 7),
            ("AND", AND, 8),
            ("XOR", XOR, 9),
            ("OR", OR, 10),
            ("MUL", MUL, 11),
            ("DIV", DIV, 12),
            ("MOD", MOD, 13),
            ("PLUS", PLUS, 14),
            ("MINUS", MINUS, 15),
            ("SHLEFT", SHLEFT, 16),
            ("SHRIGHT", SHRIGHT, 17),
            ("LES", LES, 18),
            ("LEQ", LEQ, 19),
            ("GRE", GRE, 20),
            ("GEQ", GEQ, 21),
            ("DEQ", DEQ, 22),
            ("NEQ", NEQ, 23),
            ("DAND", DAND, 24),
            ("DOR", DOR, 25),
            ("DXOR", DXOR, 26),
            ("QUEST", QUEST, 27), // c:136 — was Title-case Quest, divergent
            ("COLON", COLON, 28),
            ("EQ", EQ, 29),
            ("PLUSEQ", PLUSEQ, 30),
            ("MINUSEQ", MINUSEQ, 31),
            ("MULEQ", MULEQ, 32),
            ("DIVEQ", DIVEQ, 33),
            ("MODEQ", MODEQ, 34),
            ("ANDEQ", ANDEQ, 35),
            ("XOREQ", XOREQ, 36),
            ("OREQ", OREQ, 37),
            ("SHLEFTEQ", SHLEFTEQ, 38),
            ("SHRIGHTEQ", SHRIGHTEQ, 39),
            ("DANDEQ", DANDEQ, 40),
            ("DOREQ", DOREQ, 41),
            ("DXOREQ", DXOREQ, 42),
            ("COMMA", COMMA, 43), // c:152 — was Title-case Comma, divergent
            ("EOI", EOI, 44),
            ("PREPLUS", PREPLUS, 45),
            ("PREMINUS", PREMINUS, 46),
            ("NUM", NUM, 47),
            ("ID", ID, 48),
            ("POWER", POWER, 49),
            ("CID", CID, 50),
            ("POWEREQ", POWEREQ, 51),
            ("FUNC", FUNC, 52),
        ];
        for (name, got, want) in table {
            assert_eq!(
                got, want,
                "c:109-161 — {} must be {} (C source value)",
                name, want
            );
        }
        // TOKCOUNT = 53 must equal the table length (no holes).
        assert_eq!(
            TOKCOUNT,
            table.len() + 0,
            "c:162 — TOKCOUNT must match the number of tokens"
        );
        // QUEST sits between DXOR and COLON; gap was 26→28 BEFORE the
        // QUEST=27 fix, exposing a missing index. Pin the ordering.
        assert_eq!(QUEST, DXOR + 1, "c:136 — QUEST immediately follows DXOR");
        assert_eq!(COLON, QUEST + 1, "c:137 — COLON immediately follows QUEST");
        assert_eq!(
            COMMA,
            DXOREQ + 1,
            "c:152 — COMMA immediately follows DXOREQ"
        );
        assert_eq!(EOI, COMMA + 1, "c:153 — EOI immediately follows COMMA");
    }

    /// `Src/math.c:109-162` — the precedence and type tables MUST have
    /// length `TOKCOUNT`. Pin both lengths so a future token addition
    /// without table updates fails immediately.
    #[test]
    fn math_dispatch_tables_match_tokcount() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(
            Z_PREC.len(),
            TOKCOUNT,
            "Z_PREC must have one slot per math token"
        );
        assert_eq!(
            C_PREC.len(),
            TOKCOUNT,
            "C_PREC must have one slot per math token"
        );
        assert_eq!(
            OP_TYPE.len(),
            TOKCOUNT,
            "OP_TYPE must have one slot per math token"
        );
    }

    // ═══════════════════════════════════════════════════════════════════
    // matheval / mathevali — anchored to `zsh -c 'echo $(( ... ))'`.
    // Each expected value verified against zsh 5.9. Where zshrs diverges
    // the test FAILS, exposing the bug. matheval returns mnumber; we
    // mostly use mathevali for integer comparisons.
    // ═══════════════════════════════════════════════════════════════════

    fn mi(expr: &str) -> i64 {
        let _g = crate::test_util::global_state_lock();
        mathevali(expr).unwrap_or_else(|e| panic!("mathevali({expr:?}) → Err({e})"))
    }

    // ── Literals ────────────────────────────────────────────────────
    /// `echo $(( 42 ))` → 42
    #[test]
    fn matheval_decimal_literal() {
        assert_eq!(mi("42"), 42);
    }

    /// `echo $(( -7 ))` → -7
    #[test]
    fn matheval_unary_minus_literal() {
        assert_eq!(mi("-7"), -7);
    }

    /// `echo $(( 0xff ))` → 255
    #[test]
    fn matheval_hex_literal_lowercase() {
        assert_eq!(mi("0xff"), 255);
    }

    /// `echo $(( 0XDEAD ))` → 57005
    #[test]
    fn matheval_hex_literal_uppercase() {
        assert_eq!(mi("0XDEAD"), 0xDEAD);
    }

    /// `echo $(( 16#FF ))` → 255 (zsh base# literal)
    #[test]
    fn matheval_base_hash_hex() {
        assert_eq!(mi("16#FF"), 255);
    }

    /// `echo $(( 2#1010 ))` → 10
    #[test]
    fn matheval_base_hash_binary() {
        assert_eq!(mi("2#1010"), 10);
    }

    /// `echo $(( 8#17 ))` → 15
    #[test]
    fn matheval_base_hash_octal() {
        assert_eq!(mi("8#17"), 15);
    }

    /// `echo $(( 010 ))` → 10 (zsh default: NOT octal unless OCTAL_ZEROES set)
    #[test]
    fn matheval_leading_zero_is_decimal_not_octal() {
        assert_eq!(mi("010"), 10);
    }

    // ── Binary arithmetic ──────────────────────────────────────────
    /// `echo $(( 1 + 2 + 3 ))` → 6
    #[test]
    fn matheval_addition_chain() {
        assert_eq!(mi("1 + 2 + 3"), 6);
    }

    /// `echo $(( 2 * 3 + 4 ))` → 10 (precedence: * over +)
    #[test]
    fn matheval_precedence_mul_over_add() {
        assert_eq!(mi("2 * 3 + 4"), 10);
    }

    /// `echo $(( 2 * (3 + 4) ))` → 14 (parens override)
    #[test]
    fn matheval_parens_override_precedence() {
        assert_eq!(mi("2 * (3 + 4)"), 14);
    }

    /// `echo $(( 17 / 5 ))` → 3 (integer division, truncates toward 0)
    #[test]
    fn matheval_integer_division_truncates() {
        assert_eq!(mi("17 / 5"), 3);
    }

    /// `echo $(( 1 / 4 ))` → 0 (integer division of small numerator)
    #[test]
    fn matheval_integer_division_below_one() {
        assert_eq!(mi("1 / 4"), 0);
    }

    /// `echo $(( 17 % 5 ))` → 2
    #[test]
    fn matheval_modulo() {
        assert_eq!(mi("17 % 5"), 2);
    }

    /// `echo $(( 2 ** 10 ))` → 1024
    #[test]
    fn matheval_power() {
        assert_eq!(mi("2 ** 10"), 1024);
    }

    /// `echo $(( 3 ** 3 ))` → 27
    #[test]
    fn matheval_power_small_cubed() {
        assert_eq!(mi("3 ** 3"), 27);
    }

    /// `echo $(( -2 ** 2 ))` → 4 (zsh: unary binds tighter than **)
    #[test]
    fn matheval_unary_binds_tighter_than_power() {
        assert_eq!(mi("-2 ** 2"), 4);
    }

    // ── Bitwise ─────────────────────────────────────────────────────
    /// `echo $(( 0xff & 0x0f ))` → 15
    #[test]
    fn matheval_bitand() {
        assert_eq!(mi("0xff & 0x0f"), 15);
    }

    /// `echo $(( 0xff | 0x100 ))` → 511
    #[test]
    fn matheval_bitor() {
        assert_eq!(mi("0xff | 0x100"), 511);
    }

    /// `echo $(( 0xff ^ 0x0f ))` → 240
    #[test]
    fn matheval_bitxor() {
        assert_eq!(mi("0xff ^ 0x0f"), 240);
    }

    /// `echo $(( ~0 ))` → -1 (two's-complement bitwise NOT)
    #[test]
    fn matheval_bitnot_zero_is_minus_one() {
        assert_eq!(mi("~0"), -1);
    }

    /// `echo $(( 1 << 8 ))` → 256
    #[test]
    fn matheval_left_shift() {
        assert_eq!(mi("1 << 8"), 256);
    }

    /// `echo $(( 256 >> 4 ))` → 16
    #[test]
    fn matheval_right_shift() {
        assert_eq!(mi("256 >> 4"), 16);
    }

    /// `echo $(( -1 >> 1 ))` → -1 (arithmetic shift, sign-preserving)
    #[test]
    fn matheval_arithmetic_right_shift_preserves_sign() {
        assert_eq!(mi("-1 >> 1"), -1);
    }

    // ── Comparison & logical ───────────────────────────────────────
    /// `echo $(( 5 == 5 ))` → 1
    #[test]
    fn matheval_eq_true() {
        assert_eq!(mi("5 == 5"), 1);
    }

    /// `echo $(( 5 != 6 ))` → 1
    #[test]
    fn matheval_ne_true() {
        assert_eq!(mi("5 != 6"), 1);
    }

    /// `echo $(( 3 < 5 ))` → 1
    #[test]
    fn matheval_lt_true() {
        assert_eq!(mi("3 < 5"), 1);
    }

    /// `echo $(( 5 <= 5 ))` → 1
    #[test]
    fn matheval_le_true_on_equal() {
        assert_eq!(mi("5 <= 5"), 1);
    }

    /// `echo $(( 1 && 1 ))` → 1
    #[test]
    fn matheval_logand_both_true() {
        assert_eq!(mi("1 && 1"), 1);
    }

    /// `echo $(( 0 || 1 ))` → 1
    #[test]
    fn matheval_logor_one_true() {
        assert_eq!(mi("0 || 1"), 1);
    }

    /// `echo $(( !0 ))` → 1
    #[test]
    fn matheval_lognot_false() {
        assert_eq!(mi("!0"), 1);
    }

    /// `echo $(( !5 ))` → 0
    #[test]
    fn matheval_lognot_truthy() {
        assert_eq!(mi("!5"), 0);
    }

    // ── Ternary ─────────────────────────────────────────────────────
    /// `echo $(( 1 ? 10 : 20 ))` → 10
    #[test]
    fn matheval_ternary_true_branch() {
        assert_eq!(mi("1 ? 10 : 20"), 10);
    }

    /// `echo $(( 0 ? 10 : 20 ))` → 20
    #[test]
    fn matheval_ternary_false_branch() {
        assert_eq!(mi("0 ? 10 : 20"), 20);
    }

    // ── Comma operator ─────────────────────────────────────────────
    /// `echo $(( (1,2,3) ))` → 3 (comma returns last)
    #[test]
    fn matheval_comma_returns_last() {
        assert_eq!(mi("(1,2,3)"), 3);
    }

    // ── Floats via matheval (mnumber tag) ──────────────────────────
    /// `1.0 / 4` returns a float (MN_FLOAT) — pin the type discriminator.
    #[test]
    fn matheval_float_div_returns_mn_float_type() {
        let _g = crate::test_util::global_state_lock();
        let n = matheval("1.0 / 4").expect("matheval");
        // MN_FLOAT flag must be set on the result type.
        assert_ne!(
            n.type_ & MN_FLOAT,
            0,
            "1.0 / 4 must carry MN_FLOAT in type; got type_=0x{:x}",
            n.type_
        );
        // d field holds the float value; should be ~0.25.
        assert!(
            (n.d - 0.25).abs() < 1e-9,
            "1.0 / 4 d-field should be 0.25; got {}",
            n.d
        );
    }

    /// `42` returns an integer (MN_INTEGER, not MN_FLOAT).
    #[test]
    fn matheval_integer_literal_returns_mn_integer_type() {
        let _g = crate::test_util::global_state_lock();
        let n = matheval("42").expect("matheval");
        assert_eq!(
            n.type_ & MN_FLOAT,
            0,
            "42 must NOT carry MN_FLOAT; got type_=0x{:x}",
            n.type_
        );
        assert_eq!(n.l, 42);
    }

    /// matheval on empty string → MN_INTEGER 0 (C c:1491-1495 fast path).
    #[test]
    fn matheval_empty_input_returns_zero() {
        let _g = crate::test_util::global_state_lock();
        let n = matheval("").expect("matheval(\"\") must succeed");
        assert_eq!(n.l, 0, "empty input → 0");
        assert_eq!(
            n.type_, MN_INTEGER,
            "empty input → MN_INTEGER (c:1491-1495)"
        );
    }

    // ── mathevali (integer-coerce front-end) ───────────────────────
    /// `mathevali` integer-coerces float results via `(zlong)x.u.d` — pin
    /// the truncation semantics (away from zero is wrong; C truncates).
    #[test]
    fn mathevali_truncates_float_toward_zero() {
        let _g = crate::test_util::global_state_lock();
        // 7.9 → truncates to 7 (NOT rounds to 8)
        assert_eq!(mathevali("7.9").unwrap(), 7);
        // -7.9 → truncates to -7 (NOT rounds to -8)
        assert_eq!(mathevali("-7.9").unwrap(), -7);
    }

    // ═══════════════════════════════════════════════════════════════════
    // zsh test-corpus pins — Test/C01arith.ztst arithmetic regression
    // suite. Each test cites the ztst line range; pass = lock current
    // correct behavior, #[ignore = "ZSHRS BUG: ..."] = tracked gap.
    // ═══════════════════════════════════════════════════════════════════

    /// `Test/C01arith.ztst:6-10` — basic integer literal.
    #[test]
    fn zsh_corpus_basic_integer_literal() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(matheval("42").unwrap().l, 42, "ztst:9 — int literal");
    }

    /// `Test/C01arith.ztst:22-25` — `((29.1 % 13.0 * 10) + 0.5)` = 31.6
    /// → integer-coerced to 31.
    #[test]
    fn zsh_corpus_float_modulo_then_int_truncation() {
        let _g = crate::test_util::global_state_lock();
        let r = mathevali("(29.1 % 13.0 * 10) + 0.5");
        assert_eq!(r.ok(), Some(31), "ztst:25 — float % then int truncation");
    }

    /// `Test/C01arith.ztst:27-29` — multi-base input:
    /// `0x10 + 0X01 + 2#1010` = 16 + 1 + 10 = 27.
    #[test]
    fn zsh_corpus_multi_base_input() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(
            mathevali("0x10 + 0X01 + 2#1010").unwrap(), 27,
            "ztst:29 — hex + 2#binary sum",
        );
    }

    /// `Test/C01arith.ztst:41-44` — float→int truncation:
    /// `(( i = 32.5 ))` then int → 32.
    #[test]
    fn zsh_corpus_float_truncates_in_integer_context() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(mathevali("32.5").unwrap(), 32, "ztst:44 — truncate, not round");
    }

    /// `Test/C01arith.ztst:46-50` — operator precedence chain:
    /// `4 - - 3 * 7 << 1 & 7 ^ 1 | 16 ** 2` = 1591 (zsh-default
    /// MATH_OPS precedence, NOT C precedence).
    #[test]
    fn zsh_corpus_zsh_precedence_chain() {
        let _g = crate::test_util::global_state_lock();
        let r = mathevali("4 - - 3 * 7 << 1 & 7 ^ 1 | 16 ** 2");
        assert_eq!(r.ok(), Some(1591), "ztst:50 — zsh-default precedence");
    }

    /// `Test/C01arith.ztst:96-97` — mixed int+float:
    /// `3 + 5 * 1.75` = 11.75 (float promotion).
    #[test]
    fn zsh_corpus_mixed_int_float_promotes_to_float() {
        let _g = crate::test_util::global_state_lock();
        let n = matheval("3 + 5 * 1.75").unwrap();
        assert!((n.d - 11.75).abs() < 1e-9,
            "ztst:96 — 3+5*1.75 = 11.75 (float promotion)");
    }

    /// `Test/C01arith.ztst:62-64` — logical precedence:
    /// `1 < 2 || 2 < 2 && 3 > 4` = 1 (|| lower than &&).
    #[test]
    fn zsh_corpus_logical_precedence_or_low_and_high() {
        let _g = crate::test_util::global_state_lock();
        let n = mathevali("1 < 2 || 2 < 2 && 3 > 4").unwrap();
        assert_eq!(n, 1, "ztst:64 — || lower than &&");
    }

    /// `Test/C01arith.ztst:66-68` — nested ternary right-associative:
    /// `1+4 ? 3+2 ? 4+3 ? 5+6 ? 4*8 : 0 : 0 : 0 : 0` = 32.
    #[test]
    fn zsh_corpus_ternary_right_associative_nested() {
        let _g = crate::test_util::global_state_lock();
        let n = mathevali("1+4 ? 3+2 ? 4+3 ? 5+6 ? 4*8 : 0 : 0 : 0 : 0").unwrap();
        assert_eq!(n, 32, "ztst:68 — nested ternary right-associative");
    }

    /// `Test/C01arith.ztst:78-80` — comma returns last:
    /// `0, 4 ? 3 : 1, 5` = 5.
    #[test]
    fn zsh_corpus_comma_returns_last_value() {
        let _g = crate::test_util::global_state_lock();
        let n = mathevali("0, 4 ? 3 : 1, 5").unwrap();
        assert_eq!(n, 5, "ztst:80 — comma operator returns last");
    }

    /// `Test/C01arith.ztst:9` — `1 + 2 * 3` = 7 (precedence).
    #[test]
    fn zsh_corpus_integer_precedence_mul_before_add() {
        let _g = crate::test_util::global_state_lock();
        let n = mathevali("1 + 2 * 3").unwrap();
        assert_eq!(n, 7, "ztst:9 — *,/ before +,-");
    }

    /// `Test/C01arith.ztst:18` — `1.5 + 2.5` = 4.0.
    #[test]
    fn zsh_corpus_basic_float_add() {
        let _g = crate::test_util::global_state_lock();
        let n = matheval("1.5 + 2.5").unwrap();
        assert!((n.d - 4.0).abs() < 1e-9, "ztst:18 — 1.5+2.5=4.0");
    }

    /// `Test/C01arith.ztst:24-26` — `7.5 % 2.5` = 0.0 (float modulo).
    #[test]
    fn zsh_corpus_float_modulo_exact_division() {
        let _g = crate::test_util::global_state_lock();
        let n = matheval("7.5 % 2.5").unwrap();
        assert!(n.d.abs() < 1e-9, "ztst:24 — 7.5%2.5=0.0");
    }

    /// `Test/C01arith.ztst:46-50` — full zsh precedence chain.
    /// `4 - - 3 * 7 << 1 & 7 ^ 1 | 16 ** 2` = 1591 under default
    /// (non-C-precedence) zsh.
    #[test]
    fn zsh_corpus_full_zsh_precedence_chain() {
        let _g = crate::test_util::global_state_lock();
        let n = mathevali("4 - - 3 * 7 << 1 & 7 ^ 1 | 16 ** 2").unwrap();
        assert_eq!(n, 1591, "ztst:50 — default zsh precedence = 1591");
    }
}