zsh/ported/

parse.rs

//! Zsh parser — direct port from zsh/Src/parse.c.
//!
//! Pulls tokens via the lex.rs free ported (zshlex/tok/tokstr) and
//! builds an AST tree (relocated to src/extensions/zsh_ast.rs as a
//! Rust-only IR) plus emits wordcode into ECBUF via the P9b/P9c
//! pipeline. Follows the zsh grammar closely; productions match
//! `par_*` in Src/parse.c.

use super::lex::{
    lextok, set_tok, AMPER, AMPERBANG, AMPOUTANG, BANG_TOK, BARAMP, BAR_TOK, CASE, COPROC, DAMPER,
    DBAR, DINANG, DINANGDASH, DINBRACK, DINPAR, DOLOOP, DONE, DOUTANG, DOUTANGAMP, DOUTANGAMPBANG,
    DOUTANGBANG, DOUTBRACK, DOUTPAR, DSEMI, ELIF, ELSE, ENDINPUT, ENVARRAY, ENVSTRING, ESAC, FI,
    FOR, FOREACH, FUNC, IF, INANGAMP, INANG_TOK, INBRACE_TOK, INOUTANG, INOUTPAR, INPAR_TOK,
    IS_REDIROP, LEXERR, LEX_HEREDOCS, NEWLIN, NOCORRECT, OUTANGAMP, OUTANGAMPBANG, OUTANGBANG,
    OUTANG_TOK, OUTBRACE_TOK, OUTPAR_TOK, REPEAT, SELECT, SEMI, SEMIAMP, SEMIBAR, SEPER,
    STRING_LEX, THEN, TIME, TRINANG, TYPESET, UNTIL, WHILE, ZEND,
};
use super::zsh_h::{
    eprog, estate, funcdump, isset, redir, unset, wc_code, wordcode, Bang, Dash, Equals, Inang,
    Outang, Tilde, ALIASFUNCDEF, COND_AND, COND_MOD, COND_MODI, COND_NOT, COND_NT, COND_OR,
    COND_REGEX, COND_STRDEQ, COND_STREQ, COND_STRGTR, COND_STRLT, COND_STRNEQ, CSHJUNKIELOOPS,
    EC_DUP, EC_NODUP, EF_HEAP, EF_REAL, EXECOPT, IGNOREBRACES, IS_DASH, MULTIFUNCDEF, OPT_ISSET,
    PM_UNDEFINED, POSIXBUILTINS, REDIRF_FROM_HEREDOC, REDIR_APP, REDIR_APPNOW, REDIR_ERRAPP,
    REDIR_ERRAPPNOW, REDIR_ERRWRITE, REDIR_ERRWRITENOW, REDIR_FROM_HEREDOC_MASK, REDIR_HEREDOC,
    REDIR_HEREDOCDASH, REDIR_HERESTR, REDIR_INPIPE, REDIR_MERGEIN, REDIR_MERGEOUT, REDIR_OUTPIPE,
    REDIR_READ, REDIR_READWRITE, REDIR_VARID_MASK, REDIR_WRITE, REDIR_WRITENOW, SHORTLOOPS,
    SHORTREPEAT, WCB_COND, WCB_SIMPLE, WC_REDIR, WC_REDIR_FROM_HEREDOC, WC_REDIR_TYPE,
    WC_REDIR_VARID, WC_SUBLIST_COPROC, WC_SUBLIST_NOT,
};
pub use crate::heredoc_ast::HereDoc;
use crate::ported::lex::{
    incasepat, incmdpos, incond, infor, input_slice, inredir, inrepeat, intypeset, isnewlin,
    lex_init, lineno, noaliases, nocorrect, pos, set_incasepat, set_incmdpos, set_incond,
    set_infor, set_inredir, set_inrepeat, set_intypeset, set_isnewlin, set_lineno, set_noaliases,
    set_nocorrect, tok, tokfd, toklineno, tokstr, zshlex,
};
use crate::ported::signals::unqueue_signals;
use crate::ported::utils::{errflag, zerr, zwarnnam, ERRFLAG_ERROR};
use crate::prompt::{cmdpop, cmdpush};
pub use crate::zsh_ast::{
    CaseArm, CaseTerm, CaseTerminator, CompoundCommand, ForList, HereDocInfo, ListFlags, ListOp,
    Redirect, RedirectOp, ShellCommand, ShellWord, SimpleCommand, SublistFlags, SublistOp,
    VarModifier, ZshAssign, ZshAssignValue, ZshCase, ZshCommand, ZshCond, ZshFor, ZshFuncDef,
    ZshIf, ZshList, ZshParamFlag, ZshPipe, ZshProgram, ZshRedir, ZshRepeat, ZshSimple, ZshSublist,
    ZshTry, ZshWhile,
};
use crate::zsh_h::{
    wc_bdata, CS_ALWAYS, CS_ARRAY, CS_CASE, CS_CMDAND, CS_CMDOR, CS_COND, CS_CURSH, CS_ELIF,
    CS_ELSE, CS_ERRPIPE, CS_FOR, CS_FOREACH, CS_FUNCDEF, CS_IF, CS_IFTHEN, CS_PIPE, CS_REPEAT,
    CS_SELECT, CS_SUBSH, CS_UNTIL, CS_WHILE, EF_RUN, WCB_ARITH, WCB_ASSIGN, WCB_CASE, WCB_CURSH,
    WCB_END, WCB_FOR, WCB_FUNCDEF, WCB_IF, WCB_LIST, WCB_PIPE, WCB_REDIR, WCB_REPEAT, WCB_SELECT,
    WCB_SUBLIST, WCB_SUBSH, WCB_TIMED, WCB_TRY, WCB_TYPESET, WCB_WHILE, WC_ASSIGN_ARRAY,
    WC_ASSIGN_INC, WC_ASSIGN_NEW, WC_ASSIGN_SCALAR, WC_CASE_AND, WC_CASE_HEAD, WC_CASE_OR,
    WC_CASE_TESTAND, WC_FOR_COND, WC_FOR_LIST, WC_FOR_PPARAM, WC_IF_ELIF, WC_IF_ELSE, WC_IF_HEAD,
    WC_IF_IF, WC_PIPE_END, WC_PIPE_LINENO, WC_PIPE_MID, WC_REDIR_WORDS, WC_SELECT_LIST,
    WC_SELECT_PPARAM, WC_SUBLIST_AND, WC_SUBLIST_END, WC_SUBLIST_FLAGS, WC_SUBLIST_OR,
    WC_SUBLIST_SIMPLE, WC_SUBLIST_TYPE, WC_TIMED_EMPTY, WC_TIMED_PIPE, WC_WHILE_UNTIL,
    WC_WHILE_WHILE, Z_ASYNC, Z_DISOWN, Z_END, Z_SIMPLE, Z_SYNC,
};
use serde::{Deserialize, Serialize};
use std::fs::{self, File};
use std::io::{Read, Seek, SeekFrom, Write};
use std::os::unix::fs::MetadataExt;
use std::path::Path;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::mpsc;
use std::thread;
use std::time::Duration;

// Names lifted out of inside-fn `use` statements (PORT.md
// 'no imports inside FNs ever').

// Direct port of `Src/parse.c:287-289` grow-policy constants.
const EC_INIT_SIZE: i32 = 256;

// Pending-here-document list — direct port of `Src/parse.c:84
// struct heredocs *hdocs;`. Per-parser file-static (bucket-1 in
// PORT_PLAN.md): each worker thread parsing a separate program needs
// its own pending-heredoc list. Saved/restored across nested parses
// by `parse_context_save`/`parse_context_restore` (parse.c:299/337).
thread_local! {
    /// Port of file-static `struct heredocs *hdocs;` from `Src/parse.c:84`.
    pub static HDOCS: std::cell::RefCell<Option<Box<crate::ported::zsh_h::heredocs>>>
        = const { std::cell::RefCell::new(None) };
}

// Wordcode-buffer thread-locals — direct port of `Src/parse.c:269-285`
// file-statics. Per-evaluator (bucket-1 in PORT_PLAN.md): each worker
// thread parsing a separate program needs its own wordcode buffer.
//
// ECBUF: the wordcode array being built. C `Wordcode ecbuf`
// (parse.c:275).
// ECLEN: allocated entries in ECBUF (parse.c:269).
// ECUSED: entries actually used so far (parse.c:271).
// ECNPATS: count of patterns referenced by ECBUF (parse.c:273).
// ECSOFFS / ECSSUB: byte offsets into the string region
// (parse.c:279). ECSSUB subtracts substring overlap.
// ECNFUNC: count of functions defined so far (parse.c:285).
// ECSTRS_INDEX: dedup index for long strings — C uses a binary tree
// of `struct eccstr` (zsh.h:836); the canonical Eccstr port exists
// at zsh_h::eccstr but stays unused at runtime here. The HashMap
// preserves the API contract (lookup by (nfunc, str) → offs) with
// simpler ownership semantics.
thread_local! {
    /// `ECBUF` static.
    pub static ECBUF: std::cell::RefCell<Vec<u32>> = std::cell::RefCell::new(Vec::new());
    static ECLEN: std::cell::Cell<i32> = const { std::cell::Cell::new(0) };
    static ECUSED: std::cell::Cell<i32> = const { std::cell::Cell::new(0) };
    static ECNPATS: std::cell::Cell<i32> = const { std::cell::Cell::new(0) };
    static ECSOFFS: std::cell::Cell<i32> = const { std::cell::Cell::new(0) };
    static ECSSUB: std::cell::Cell<i32> = const { std::cell::Cell::new(0) };
    static ECNFUNC: std::cell::Cell<i32> = const { std::cell::Cell::new(0) };
    static ECSTRS_INDEX: std::cell::RefCell<std::collections::HashMap<(i32, String), u32>>
        = std::cell::RefCell::new(std::collections::HashMap::new());
    /// C zsh's `eccstr` BST (parse.c:447). Port of `Eccstr ecstrs` —
    /// a hashval-ordered binary search tree of long-strings for
    /// dedup. Same cmp logic as C: nfunc, then hashval, then strcmp.
    /// HashMap above is a fast-path lookup; this tree is the
    /// C-fidelity walker that mirrors C's exact dedup-hit pattern
    /// (including its quirks for hash-colliding content).
    static ECSTRS_TREE: std::cell::RefCell<Option<Box<EccstrNode>>>
        = const { std::cell::RefCell::new(None) };
    /// Reverse index for `ecgetstr`: offs → owned string. Populated
    /// at ecstrcode time so the consumer can recover the string from
    /// the wordcode offs without walking the encode-time HashMap.
    /// Stores the METAFIED BYTE form of each long-string, exactly
    /// matching what C's strs region holds. `String` would not work
    /// here because Rust strings carry UTF-8-encoded chars (e.g.
    /// the Dash marker `\u{e19b}` UTF-8-encodes to two bytes
    /// `\xc2 \x9b`) while C stores zsh markers as single bytes
    /// (raw `\x9b`). Storing Vec<u8> lets us write byte-for-byte
    /// what C writes after metafy.
    pub static ECSTRS_REVERSE: std::cell::RefCell<std::collections::HashMap<u32, Vec<u8>>>
        = std::cell::RefCell::new(std::collections::HashMap::new());
}
const EC_DOUBLE_THRESHOLD: i32 = 32768;
const EC_INCREMENT: i32 = 1024;

/// Port of `#define YYERROR(O) { tok = LEXERR; ecused = (O); return 0; }`
/// from `Src/parse.c:87`. Only flags the error: the one diagnostic,
/// "parse error near `<zshlextext>'", is printed by `yyerror` once the
/// parse unwinds to `parse_list` / `par_event`.
macro_rules! YYERROR {
    ($o:expr) => {{
        set_tok(LEXERR);
        ECUSED.set(($o) as i32);
        return 0;
    }};
}

/// Port of `#define YYERRORV(O) { tok = LEXERR; ecused = (O); return; }`
/// from `Src/parse.c:88` — the `void` twin of `YYERROR`.
macro_rules! YYERRORV {
    ($o:expr) => {{
        set_tok(LEXERR);
        ECUSED.set(($o) as i32);
        return;
    }};
}

/// Port of `#define COND_ERROR(X,Y)` from `Src/parse.c:89-96`:
/// `zwarn(X,Y); herrflush(); if (noerrs != 2) errflag |= ERRFLAG_ERROR;
/// YYERROR(ecused)`. The `%s` conversion is `nicezputs` (c:Src/utils.c:311),
/// which untokenizes through `ztokens`; Rust pre-formats the message, so the
/// macro applies that step to the argument (`nicedupstring`).
macro_rules! COND_ERROR {
    ($fmt:literal, $arg:expr) => {{
        crate::ported::utils::zwarn(&format!(
            $fmt,
            crate::ported::utils::nicedupstring($arg)
        ));
        crate::ported::hist::herrflush();
        if *crate::ported::utils::noerrs_lock().lock().unwrap() != 2 {
            crate::ported::utils::errflag
                .fetch_or(crate::ported::zsh_h::ERRFLAG_ERROR, Ordering::SeqCst);
        }
        YYERROR!(ECUSED.get());
    }};
}

/// Port of `parse_context_save()` from `Src/parse.c:295` — C signature `parse_context_save(struct parse_stack *ps, int toplevel)`.
/// Snapshots the lexer-side file-statics plus the pending heredoc list,
/// plus the wordcode-buffer state (`ecbuf`, `ecstrs`, `ecused`, ...).
/// Saves Rust-only recursion counters too so nested parses get fresh limits.
/// WARNING: param names don't match C — Rust=(ps) vs C=(ps, toplevel)
pub fn parse_context_save(ps: &mut parse_stack) {
    // parse.c:299 — `ps->hdocs = hdocs; hdocs = NULL;` — save the
    // canonical C linked-list and clear it for the nested parse.
    ps.hdocs = HDOCS.with_borrow_mut(|h| h.take());
    // zshrs-only: save the parallel AST-glue Vec the same way.
    // LEX_HEREDOCS carries terminator/strip_tabs/quoted metadata
    // that has no C analog (C stores it implicitly via tokstr).
    ps.lex_heredocs = LEX_HEREDOCS.with_borrow_mut(|v| std::mem::take(v));
    // parse.c:302-310 — save lexer-side state.
    ps.incmdpos = incmdpos();
    // parse.c:303 — `ps->aliasspaceflag = aliasspaceflag;`. Mirrors
    // lex.c LEX_ALIAS_SPACE_FLAG so nested parses preserve the
    // HISTIGNORESPACE-via-alias state across parser re-entry.
    ps.aliasspaceflag = crate::ported::lex::LEX_ALIAS_SPACE_FLAG.with(|c| c.get());
    ps.incond = incond();
    ps.inredir = inredir();
    ps.incasepat = incasepat();
    ps.isnewlin = isnewlin();
    ps.infor = infor();
    ps.inrepeat_ = inrepeat();
    ps.intypeset = intypeset();
    // c:310-318 — the wordcode buffer being built. A nested parse's
    // `init_parse` (c:513-522) resets all of it, so without this an
    // enclosing wordcode parse (`zcompile` reaching a `$(…)`, whose
    // skipcomm runs `parse_event(OUTPAR)`) lost everything it had emitted.
    //
    // !!! WARNING: COPIED, NOT HANDED OVER !!! C moves the buffer into `ps`
    // and sets `ecbuf = NULL` (c:318); every C nested parse then starts
    // with `init_parse`. The copy leaves the thread-locals readable for a
    // Rust nested parse that skips `init_parse`, where C would dereference
    // NULL; `parse_context_restore` overwrites them either way.
    ps.eclen = ECLEN.get();
    ps.ecused = ECUSED.get();
    ps.ecnpats = ECNPATS.get();
    ps.ecbuf = Some(ECBUF.with_borrow(|b| b.clone()));
    ps.ecstrs = ECSTRS_TREE.with_borrow(|t| t.clone());
    ps.ecstrs_index = ECSTRS_INDEX.with_borrow(|m| m.clone());
    ps.ecstrs_reverse = ECSTRS_REVERSE.with_borrow(|m| m.clone());
    ps.ecsoffs = ECSOFFS.get();
    ps.ecssub = ECSSUB.get();
    ps.ecnfunc = ECNFUNC.get();
    set_incmdpos(true);
    set_incond(0);
    set_inredir(false);
    set_incasepat(0);
    set_infor(0);
    set_inrepeat(0);
    set_intypeset(false);
}

/// Port of `parse_context_restore()` from `Src/parse.c:326` — C signature `parse_context_restore(const struct parse_stack *ps, int toplevel)`.
/// Inverse of `parse_context_save`. Restores lexer-side state +
/// pending heredocs + Rust-only counters from `ps`, then clears
/// `errflag & ERRFLAG_ERROR` per parse.c:354.
/// WARNING: param names don't match C — Rust=(ps) vs C=(ps, toplevel)
pub fn parse_context_restore(ps: &parse_stack) {
    // parse.c:330-331 — free any in-progress wordcode buffer: the nested
    // parse's buffer is overwritten by the saved one below.

    // parse.c:333-352 — restore saved state.
    // parse.c:337 — `hdocs = ps->hdocs;`
    HDOCS.with_borrow_mut(|h| *h = ps.hdocs.clone());
    // zshrs-only: restore the parallel AST-glue Vec.
    LEX_HEREDOCS.with_borrow_mut(|v| *v = ps.lex_heredocs.clone());
    set_incmdpos(ps.incmdpos);
    // parse.c:334 — `aliasspaceflag = ps->aliasspaceflag;`.
    crate::ported::lex::LEX_ALIAS_SPACE_FLAG.with(|c| c.set(ps.aliasspaceflag));
    set_incond(ps.incond);
    set_inredir(ps.inredir);
    set_incasepat(ps.incasepat);
    set_isnewlin(ps.isnewlin);
    set_infor(ps.infor);
    set_inrepeat(ps.inrepeat_);
    set_intypeset(ps.intypeset);
    // c:330-331, c:345-352 — drop the nested buffer, put the saved one back.
    ECLEN.set(ps.eclen);
    ECUSED.set(ps.ecused);
    ECNPATS.set(ps.ecnpats);
    ECBUF.with_borrow_mut(|b| *b = ps.ecbuf.clone().unwrap_or_default());
    ECSTRS_TREE.with_borrow_mut(|t| *t = ps.ecstrs.clone());
    ECSTRS_INDEX.with_borrow_mut(|m| *m = ps.ecstrs_index.clone());
    ECSTRS_REVERSE.with_borrow_mut(|m| *m = ps.ecstrs_reverse.clone());
    ECSOFFS.set(ps.ecsoffs);
    ECSSUB.set(ps.ecssub);
    ECNFUNC.set(ps.ecnfunc);

    // parse.c:354 — `errflag &= ~ERRFLAG_ERROR;` — clear the
    // error flag so the outer parse sees a clean state.
    errflag.fetch_and(!ERRFLAG_ERROR, Ordering::Relaxed);
}

/// Port of `ecadjusthere()` from `Src/parse.c:360` — C signature `ecadjusthere(int p, int d)`. Walk
/// the pending-heredocs list and bump each `pc` by `d` if it's
/// at or after position `p`. Called by `ecispace` / `ecdel` when
/// wordcodes shift.
pub fn ecadjusthere(p: usize, d: i32) {
    // c:362 `struct heredocs *h;`
    // c:364-366 — `for (h = hdocs; h; h = h->next) if (h->pc >= p)
    // h->pc += d;`. par_redir records each pending here-document's
    // wordcode position in HDOCS (c:2290-2296); when par_pipe/par_sublist
    // later open a slot in front of it (a `cat <<X | cat` stage gets its
    // WC_PIPE header inserted), setheredoc must still patch the redirection
    // it recorded, not the word that slid into its old position.
    HDOCS.with_borrow_mut(|head| {
        let mut h = head.as_deref_mut();
        while let Some(node) = h {
            if node.pc >= p as i32 {
                node.pc += d; // c:366
            }
            h = node.next.as_deref_mut();
        }
    });
}

// === AST tree relocated to src/extensions/zsh_ast.rs ===
//
// zsh C does NOT have an AST tree — it emits wordcode directly via
// par_event/par_list/par_sublist/par_pipe/par_cmd/par_simple/etc.
// (Src/parse.c:485-3000) into a flat `Wordcode ecbuf[]`. The Zsh*/
// Shell* AST node types lived in this file as a Rust-only IR that
// stands in for that wordcode.
//
// P9e (PORT_PLAN.md): the types moved to src/extensions/zsh_ast.rs
// to make their Rust-only-extension nature explicit. The full P9c +
// P9d rewrite (par_* emitting wordcode + vm_helper reading wordcode)
// retires them entirely — until then, callers reach them via this
// re-export.

/// Port of `ecispace()` from `Src/parse.c:372` — C signature `ecispace(int p, int n)`. Insert `n`
/// empty wordcode slots at position `p`, shifting later entries
/// right, growing the buffer as needed, adjusting heredoc pointers.
pub fn ecispace(p: usize, n: usize) {
    // parse.c:376-381 — grow if needed.
    let need = n as i32;
    if (ECLEN.get() - ECUSED.get()) < need {
        let cur = ECLEN.get();
        let mut a = if cur < EC_DOUBLE_THRESHOLD {
            cur
        } else {
            EC_INCREMENT
        };
        if need > a {
            a = need;
        }
        ECBUF.with_borrow_mut(|buf| {
            buf.resize((cur + a) as usize, 0);
        });
        ECLEN.set(cur + a);
    }
    // parse.c:382-385 — memmove p → p+n, gap of n.
    let m = ECUSED.get() as usize - p;
    if m > 0 {
        ECBUF.with_borrow_mut(|buf| {
            let needed = (ECUSED.get() as usize) + n;
            if buf.len() < needed {
                buf.resize(needed, 0);
            }
            for i in (0..m).rev() {
                buf[p + n + i] = buf[p + i];
            }
            for i in 0..n {
                buf[p + i] = 0;
            }
        });
    }
    // parse.c:386 — bump ecused by n.
    ECUSED.set(ECUSED.get() + need);
    // parse.c:387 — `ecadjusthere(p, n)`.
    ecadjusthere(p, need);
}

/// Port of `ecadd()` from `Src/parse.c:397` — C signature `ecadd(wordcode c)`. Append `c` to
/// the wordcode buffer with grow-on-demand, return the new index.
pub fn ecadd(c: u32) -> usize {
    // parse.c:399-405 — `if ((eclen - ecused) < 1) grow`.
    if (ECLEN.get() - ECUSED.get()) < 1 {
        let cur = ECLEN.get();
        let a = if cur < EC_DOUBLE_THRESHOLD {
            cur
        } else {
            EC_INCREMENT
        };
        ECBUF.with_borrow_mut(|buf| {
            buf.resize((cur + a) as usize, 0);
        });
        ECLEN.set(cur + a);
    }
    let idx = ECUSED.get();
    ECBUF.with_borrow_mut(|buf| {
        if (idx as usize) >= buf.len() {
            buf.resize((idx + 1) as usize, 0);
        }
        buf[idx as usize] = c;
    });
    ECUSED.set(idx + 1);
    idx as usize
}

/// Port of `ecdel()` from `Src/parse.c:413` — C signature `ecdel(int p)`. Remove the
/// wordcode at position `p`, shift later entries left by one,
/// decrement ecused, adjust pending heredoc pointers.
pub fn ecdel(p: usize) {
    // parse.c:415-418 — memmove + decrement ecused.
    let n = ECUSED.get() as usize - p - 1;
    if n > 0 {
        ECBUF.with_borrow_mut(|buf| {
            for i in 0..n {
                buf[p + i] = buf[p + i + 1];
            }
        });
    }
    ECUSED.set(ECUSED.get() - 1);
    // parse.c:420 — `ecadjusthere(p, -1)`.
    ecadjusthere(p, -1);
}

/// Port of `ecstrcode()` from `Src/parse.c:426` — C signature `ecstrcode(char *s)`. Encode a
/// string into a single wordcode (short strings ≤4 bytes packed
/// inline; longer strings get an offset into the deduped registry).
///
/// The long-string path stores the METAFIED bytes (matches what C's
/// strs region contains): collapse Rust UTF-8 chars in 0x80..=0xff
/// to single bytes, then apply zsh metafy (high bytes ≥ 0x83 →
/// `Meta=0x83 + byte^0x20`). Length tracking (ECSOFFS) uses the
/// metafied byte count — same as C `strlen(s) + 1` where C's `s`
/// is already metafied at this point.
pub fn ecstrcode(s: &str) -> u32 {
    // Convert Rust char-form → C-byte form. zsh's metafy() at
    // Src/utils.c only converts bytes flagged IMETA: 0x00, 0x83
    // (Meta itself), and 0x84..=0xa2 (Pound..Marker, the lex
    // markers). Other bytes 0x01..=0x82 and 0xa3..=0xff pass
    // through unchanged. See utils.c:4195-4204 typtab init.
    //
    // Rust receives chars. Classify each:
    //   - a lex token char (PUA, crate::token_char) → its single C
    //     token byte, as C's lexer adds it
    //   - codepoint < 0x80 → ASCII, 1 byte unchanged
    //   - codepoint in [0x80..=0x82] or [0xa3..=0xff] → single
    //     non-imeta byte (user-input range); 1 byte unchanged
    //   - codepoint > 0xff → multi-byte UTF-8 source char (e.g.
    //     '━' = U+2501 = 0xe2 0x94 0x81). Metafy ONLY the bytes
    //     that fall in 0x83..=0xa2; pass others through. For '━':
    //     0xe2 stays, 0x94 → 0x83 0xb4, 0x81 stays.
    let mut c_bytes: Vec<u8> = Vec::with_capacity(s.len());
    let imeta = |b: u8| -> bool { b == 0 || (0x83..=0xa2).contains(&b) };
    let mut it = s.chars().peekable();
    while let Some(ch) = it.next() {
        // A `Meta` (U+0083) followed by a scalar in U+0080..=U+00FF is
        // zshrs's char-level encoding of ONE raw byte — what `$'\xNN'`
        // emits (lex.rs `getkeystring_dollar_quote`), what
        // `script_bytes::decode_script_bytes` produces for a non-UTF-8
        // script byte, and what `utils::unmetafy_str` reverses at the
        // write boundary. U+0083 is never a token: the token range starts
        // at `Pound` U+e184 (zsh_h.rs:159), so this cannot swallow a lex
        // marker. Recover the byte and let the imeta rule below decide,
        // exactly as C does for a byte read off the file: `caf\xe9`
        // stores `63 61 66 e9` like zsh, where re-encoding the pair as
        // text stored `63 61 66 83 c3 83 a9` and read back as garbage.
        if ch == '\u{83}' {
            if let Some(&n) = it.peek() {
                let nu = n as u32;
                if (0x80..=0xff).contains(&nu) {
                    it.next();
                    let b = (nu as u8) ^ 32;
                    if imeta(b) {
                        c_bytes.push(0x83);
                        c_bytes.push(b ^ 0x20);
                    } else {
                        c_bytes.push(b);
                    }
                    continue;
                }
            }
        }
        let cu = ch as u32;
        if cu < 0x80 {
            // ASCII — single byte unchanged.
            c_bytes.push(cu as u8);
        } else if let Some(b) = crate::token_char::token_byte(ch) {
            // Lex token char: stored as its single C byte, as C's lexer
            // adds it. Real U+0083..=U+00A2 text is not a token and takes
            // the metafy branch below like any other data.
            c_bytes.push(b);
        } else {
            // User-input char: encode UTF-8 then metafy imeta bytes.
            // For chars 0x80..=0xff (like 'º' U+00BA), UTF-8 gives
            // 2 bytes (e.g. `0xc2 0xba`) — zsh's lex reads these as
            // raw bytes from input and metafy passes 0xc2 / 0xba
            // through (both NOT imeta).
            let mut tmp = [0u8; 4];
            for &b in ch.encode_utf8(&mut tmp).as_bytes() {
                if imeta(b) {
                    c_bytes.push(0x83);
                    c_bytes.push(b ^ 0x20);
                } else {
                    c_bytes.push(b);
                }
            }
        }
    }
    // c:`has_token` (Src/utils.c:2282) → `itok(*s)` → `typtab[c] & ITOK`.
    // ITOK is set for bytes `Pound..=Nularg` (0x84..=0xa1) per
    // Src/utils.c:4198 (`for (t0=Pound; t0<=LAST_NORMAL_TOK; t0++)
    // typtab[t0]|=ITOK`) plus :4200 (`for (t0=Snull; t0<=Nularg; t0++)
    // typtab[t0]|=ITOK|IMETA|INULL`). Pound=0x84 Bang=0x9c (last normal),
    // Snull=0x9d..Nularg=0xa1. Meta=0x83 has IMETA but NOT ITOK.
    let t = c_bytes.iter().any(|&b| (0x84..=0xa1).contains(&b));
    let l = c_bytes.len() + 1; // include NUL terminator
    if l <= 4 {
        // parse.c:436-445 — short-string inline pack. Uses raw C-bytes
        // (NOT metafied — the inline packing stores 1 byte per slot).
        let mut c: u32 = if t { 3 } else { 2 };
        match l {
            4 => {
                c |= (c_bytes[2] as u32) << 19;
                c |= (c_bytes[1] as u32) << 11;
                c |= (c_bytes[0] as u32) << 3;
            }
            3 => {
                c |= (c_bytes[1] as u32) << 11;
                c |= (c_bytes[0] as u32) << 3;
            }
            2 => {
                c |= (c_bytes[0] as u32) << 3;
            }
            1 => {
                // parse.c:443 — empty string special case.
                c = if t { 7 } else { 6 };
            }
            _ => {}
        }
        c
    } else {
        // parse.c:447-466 — long string. Port of C's eccstr BST walk
        // exactly: walk the tree comparing nfunc, then hashval, then
        // strcmp on bytes. Return offs on full match; insert new
        // leaf otherwise. Matches C's exact dedup-hit pattern
        // (which is content-dependent — hash collisions and the
        // lazy short-circuit cmp chain make the tree shape determine
        // whether matching nodes are reachable).
        // hasher is byte-by-byte polynomial (hashtable.c:86); pass
        // c_bytes via from_utf8_unchecked so non-UTF-8 zsh marker
        // bytes feed straight in. SAFETY: hasher only iterates
        // `.bytes()` — no UTF-8 validity assumed.
        let val =
            crate::ported::hashtable::hasher(unsafe { std::str::from_utf8_unchecked(&c_bytes) });
        let nfunc = ECNFUNC.get();
        let found_offs = ECSTRS_TREE.with_borrow_mut(|root| {
            // Walk the tree. At each node, if all 3 cmps == 0,
            // return the node's offs. Otherwise descend left/right
            // by the first non-zero cmp's sign.
            let mut cur: &mut Option<Box<EccstrNode>> = root;
            loop {
                let p = match cur.as_mut() {
                    Some(p) => p,
                    None => break None,
                };
                // c:448 — `cmp = p->nfunc - ecnfunc`
                let mut cmp = (p.nfunc as i64) - (nfunc as i64);
                if cmp == 0 {
                    // c:448 — `&& !(cmp = (long)p->hashval - (long)val)`
                    // C does `(int)(p->hashval - val)` — unsigned 32-bit
                    // subtraction wraps, then cast to int. Use
                    // wrapping_sub + as i32 to match the bit pattern.
                    cmp = (p.hashval.wrapping_sub(val) as i32) as i64;
                    if cmp == 0 {
                        // c:448 — `&& !(cmp = strcmp(p->str, s))`
                        cmp = match p.str.as_slice().cmp(c_bytes.as_slice()) {
                            std::cmp::Ordering::Less => -1,
                            std::cmp::Ordering::Equal => 0,
                            std::cmp::Ordering::Greater => 1,
                        };
                        if cmp == 0 {
                            // c:450 — `return p->offs;`
                            break Some(p.offs);
                        }
                    }
                }
                // c:452 — `pp = (cmp < 0 ? &p->left : &p->right);`
                cur = if cmp < 0 { &mut p.left } else { &mut p.right };
            }
        });
        if let Some(offs) = found_offs {
            return offs;
        }
        // c:462 — `p->offs = ((ecsoffs - ecssub) << 2) | (t ? 1 : 0);`
        let offs = (((ECSOFFS.get() - ECSSUB.get()) as u32) << 2) | if t { 1 } else { 0 };
        // c:463 — `p->aoffs = ecsoffs;` (absolute write position).
        let aoffs = ECSOFFS.get() as u32;
        // c:457-465 — insert new node at the NULL slot the walk
        // terminated at. Encode the walk path as a Vec<bool> of
        // left/right turns (true = right), then re-descend to
        // insert. Borrow-checker friendly: a single mutable walk
        // that either finds an existing node (descend) or fills
        // the empty slot (return).
        let stored = c_bytes.clone();
        let stored_len = stored.len();
        let new_node = Box::new(EccstrNode {
            left: None,
            right: None,
            str: stored.clone(),
            offs,
            aoffs,
            nfunc,
            hashval: val,
        });
        ECSTRS_TREE.with_borrow_mut(|root| {
            // Build the path first (immutable-walk; safe because we
            // only ever go further down).
            let mut path: Vec<bool> = Vec::new();
            {
                let mut cur: &Option<Box<EccstrNode>> = root;
                while let Some(p) = cur.as_ref() {
                    let mut cmp = (p.nfunc as i64) - (nfunc as i64);
                    if cmp == 0 {
                        // C does `(int)(p->hashval - val)` — unsigned 32-bit
                        // subtraction wraps, then cast to int. Use
                        // wrapping_sub + as i32 to match the bit pattern.
                        cmp = (p.hashval.wrapping_sub(val) as i32) as i64;
                        if cmp == 0 {
                            cmp = match p.str.as_slice().cmp(c_bytes.as_slice()) {
                                std::cmp::Ordering::Less => -1,
                                std::cmp::Ordering::Equal => 0,
                                std::cmp::Ordering::Greater => 1,
                            };
                        }
                    }
                    let go_right = cmp >= 0;
                    path.push(go_right);
                    cur = if go_right { &p.right } else { &p.left };
                }
            }
            // Descend mutably along the recorded path and assign at
            // the NULL leaf.
            let mut cur: &mut Option<Box<EccstrNode>> = root;
            for turn in path {
                let p = cur.as_mut().expect("path matches walk");
                cur = if turn { &mut p.right } else { &mut p.left };
            }
            *cur = Some(new_node);
        });
        // Also keep the existing reverse index (offs → bytes) for
        // ecgetstr_wordcode and copy_ecstr — they read flat by offs.
        ECSTRS_REVERSE.with_borrow_mut(|m| {
            m.insert(offs, stored);
        });
        let _ = l;
        ECSOFFS.set(ECSOFFS.get() + (stored_len + 1) as i32);
        offs
    }
}

/// Port of `init_parse_status()` from `Src/parse.c:491`.
/// Initialize parser status. Clears the per-parse-call lexer flags
/// so a fresh parse starts from cmd-position with no nesting
/// state inherited from a prior parse.
///
/// Previously the Rust port omitted `inrepeat_ = 0` at c:501.
/// `inrepeat_` is the `repeat N <body>` parse-state counter that
/// the lexer toggles in 3 phases (1 → 2 → 3 → 0). Without the
/// reset, a fresh parse called after an in-flight `repeat`
/// command would inherit the stale counter and silently misread
/// the next token as a body of an already-completed repeat.
pub fn init_parse_status() {
    // c:491
    // parse.c:500-502 — `incasepat = incond = inredir = infor =
    // intypeset = 0; inrepeat_ = 0; incmdpos = 1;`
    set_incasepat(0); // c:500
    set_incond(0); // c:500
    set_inredir(false); // c:500
    set_infor(0); // c:500
    set_intypeset(false); // c:500
    set_inrepeat(0); // c:501 inrepeat_ = 0
    set_incmdpos(true); // c:502
}

/// Port of `init_parse()` from `Src/parse.c:509`.
/// Initialize parser for a fresh parse. C source allocates a
/// fresh wordcode buffer (ecbuf) sized EC_INIT_SIZE, resets the
/// per-parse-call counters, and calls init_parse_status. zshrs
/// has no flat wordcode buffer (AST is built inline) so this
/// function reduces to init_parse_status + recursion_depth/
/// global_iterations clear.
pub fn init_parse() {
    // parse.c:513-520 — `ecbuf = (Wordcode) zalloc(EC_INIT_SIZE *
    // sizeof(wordcode)); eclen = EC_INIT_SIZE; ecused = 0;
    // ecnpats = 0; ecstrs = NULL; ecsoffs = ecnfunc = 0;
    // ecssub = 0;`. P9b — initialize the per-evaluator wordcode
    // buffer for this parse call. zshrs uses thread-local
    // statics declared at file scope (parse.rs:25-50).
    ECBUF.with_borrow_mut(|buf| {
        buf.clear();
        buf.resize(EC_INIT_SIZE as usize, 0);
    });
    ECLEN.set(EC_INIT_SIZE);
    ECUSED.set(0);
    ECNPATS.set(0);
    ECSOFFS.set(0);
    ECSSUB.set(0);
    ECNFUNC.set(0);
    ECSTRS_INDEX.with_borrow_mut(|m| m.clear());
    ECSTRS_REVERSE.with_borrow_mut(|m| m.clear());
    ECSTRS_TREE.with_borrow_mut(|t| *t = None);

    // parse.c:522 — `init_parse_status();`
    init_parse_status();
}

/// Port of `copy_ecstr()` from `Src/parse.c:537` — C signature `copy_ecstr(Eccstr s, char *p)`.
/// Walks the BST and writes each entry to `p[s->aoffs..]` matching
/// C's recursive in-order traversal exactly. The old impl used the
/// `ECSTRS_REVERSE` HashMap keyed by `offs` (= ecssub-relative
/// wordcode-encoded offset), which collides across funcdef scopes:
/// a string at relative offs=0 inside funcdef A and another at
/// relative offs=0 inside funcdef B share the same key, so one
/// overwrites the other.
pub fn copy_ecstr(_table: &std::collections::HashMap<u32, Vec<u8>>, p: &mut [u8]) {
    // c:537-544 — walk eccstr BST recursively, writing each node's
    // str at p[node->aoffs..node->aoffs + strlen + 1] (NUL-terminated).
    ECSTRS_TREE.with_borrow(|root| {
        copy_ecstr_walk(root, p);
    });
}

/// Port of `bld_eprog()` from `Src/parse.c:547` — C signature `bld_eprog(int heap)`. Finalizes
/// the in-build `ECBUF`/`ECSTRS`/`ECNPATS` state into an `Eprog`.
/// Resets the build state so a new parse can start.
pub fn bld_eprog(heap: bool) -> eprog {
    // c:547

    // c:555 — emit WC_END opcode. `WCB_END` is `WC_END_DEFAULT` (0).
    ecadd(0);

    let ecused = ECUSED.with(|c| c.get()) as usize;
    let ecnpats = ECNPATS.with(|c| c.get()) as usize;
    let ecsoffs = ECSOFFS.with(|c| c.get()) as usize;

    // c:557-559 — `ret->len = ((ecnpats * sizeof(Patprog)) +
    //                            (ecused * sizeof(wordcode)) +
    //                            ecsoffs);`
    // sizeof(Patprog) = sizeof(struct patprog *) = pointer size.
    // On 64-bit targets that's 8, on 32-bit that's 4. C's eprog
    // ->len is the canonical value for parity tests, so we use
    // the same arithmetic.
    let prog_bytes = ecused * 4; // sizeof(wordcode) = 4
    let len = (ecnpats * size_of::<*const u8>()) + prog_bytes + ecsoffs;

    // Snapshot the wordcode buffer + string table.
    let prog_words: Vec<u32> = ECBUF.with(|c| c.borrow()[..ecused].to_vec());
    let mut strs_bytes = vec![0u8; ecsoffs];
    ECSTRS_REVERSE.with(|c| copy_ecstr(&c.borrow(), &mut strs_bytes));

    // c:566 — store strs as raw bytes via from_utf8_unchecked so
    // single-byte zsh markers (e.g. Dash 0x9b) survive intact.
    // `String::from_utf8_lossy` would replace them with U+FFFD
    // (`\xef\xbf\xbd`), breaking byte-for-byte parity with C's
    // strs region. SAFETY: downstream consumers of `eprog.strs`
    // index by byte offset (per the wordcode `(offs >> 2)` offset
    // encoding) and call `.as_bytes()` — they never iterate as
    // chars or rely on UTF-8 validity, so storing non-UTF-8 bytes
    // in a String is safe in practice. C zsh's strs is `char *`
    // with the same byte-not-char semantics.
    let strs_string = unsafe { String::from_utf8_unchecked(strs_bytes) };
    let ret = eprog {
        flags: if heap { EF_HEAP } else { EF_REAL }, // c:570
        len: len as i32,                             // c:559
        npats: ecnpats as i32,                       // c:561
        nref: if heap { -1 } else { 1 },             // c:562
        pats: Vec::new(),                            // c:563 dummy_patprog
        prog: prog_words,                            // c:565
        strs: Some(strs_string),
        shf: None,
        dump: None,
        // The pool `ecstrcode` (c:426) just built is METAFIED — that
        // function encodes every IMETA byte as `Meta` + `b ^ 0x20`
        // (parse.rs:363-389) and the wordcode offsets it hands back
        // count metafied bytes. Flagging the pool clean made
        // `ecgetstr` skip `unmetafy`, so any multibyte glyph with a
        // continuation byte in 0x83..=0xa2 came back mangled
        // (`—` E2 80 94 → stored E2 80 83 B4 → decoded U+2003 + U+00B4).
        strs_metafied: true,
    };

    // c:577 — free ecbuf so next parse starts fresh.
    ECBUF.with(|c| c.borrow_mut().clear());
    ECLEN.with(|c| c.set(0));
    ECUSED.with(|c| c.set(0));
    ECNPATS.with(|c| c.set(0));
    ECSOFFS.with(|c| c.set(0));
    ECSTRS_INDEX.with(|c| c.borrow_mut().clear());
    ECSTRS_REVERSE.with(|c| c.borrow_mut().clear());
    ECSTRS_TREE.with(|t| *t.borrow_mut() = None);

    ret
}

/// Port of `empty_eprog()` from `Src/parse.c:584` — C signature `empty_eprog(Eprog p)`. C
/// body: `return (!p || !p->prog || *p->prog == WCB_END());` —
/// the eprog is empty when its prog buffer is missing or the
/// first wordcode is the WC_END marker. Used by signal handlers
/// (`Src/signals.c:712`) to short-circuit a trap that resolves to
/// an empty program.
pub fn empty_eprog(p: &eprog) -> bool {
    p.prog.is_empty() || p.prog[0] == WCB_END()
}

/// Port of `clear_hdocs()` from `Src/parse.c:591` — C signature `clear_hdocs(void)`.
/// Clear pending here-document list. The C version walks
/// `hdocs` and frees each node; Rust drops the `Box<heredocs>`
/// chain automatically when the head is replaced with None.
pub fn clear_hdocs() {
    // c:591
    // c:593-598 — for (p = hdocs; p; p = n) { n = p->next; zfree(p); }
    // c:599 — hdocs = NULL;
    HDOCS.with_borrow_mut(|h| *h = None);
    // zshrs-only: also drop the parallel AST-glue Vec. No C
    // analog — LEX_HEREDOCS is Rust-only working-set state.
    LEX_HEREDOCS.with_borrow_mut(|v| v.clear());
}

/// Port of `parse_event()` from `Src/parse.c:614` (body c:615-631).
/// Top-level parse-event entry. Reads one event from the lexer (a
/// sublist optionally followed by SEPER/AMPER/AMPERBANG) and
/// returns the resulting ZshProgram.
///
/// `endtok` is the token that terminates the event — usually
/// ENDINPUT, but for command-style substitutions the closing
/// `)` (zsh's CMD_SUBST_CLOSE).
///
/// zshrs port note: zsh's parse_event returns an `Eprog` (heap-
/// allocated wordcode program). zshrs returns a `ZshProgram`
/// (AST root). Same role at the parse-output boundary.
pub fn parse_event(endtok: lextok) -> Option<ZshProgram> {
    // parse.c:616-619 — reset state and prime the lexer.
    set_tok(ENDINPUT);
    set_incmdpos(true);
    // parse.c:618 — `aliasspaceflag = 0;`. Fresh event: discard any
    // alias-space carry-over from a prior parse so HISTIGNORESPACE
    // doesn't suppress the next entered command line.
    crate::ported::lex::LEX_ALIAS_SPACE_FLAG.with(|c| c.set(0));

    // parse.c:626-628 — a sub-parse for a substitution (endtok !=
    // ENDINPUT, e.g. `par_subsh` with OUTPAR) doesn't need its own
    // eprog; par_event drives it and the caller discards the program.
    if endtok != ENDINPUT {
        zshlex();
        init_parse();
        if !par_event(endtok) {
            clear_hdocs();
            return None;
        }
        return Some(ZshProgram { lists: Vec::new() });
    }

    // parse.c:616-630 — top-level event parse. The lexer pulls
    // characters straight from SHIN via hgetc → ingetc → shingetchar
    // (input.c) and accumulates each into its token buffer with add();
    // no LEX_INPUT seeding. `zshlex()` (already primed by the shared
    // entry below) reads the first token; parse_program_until drives the
    // grammar over the event, refilling input one line at a time as
    // ingetc's inputline() arm fires.
    zshlex();
    init_parse();
    if tok() == ENDINPUT {
        return None; // EOF — loop() terminates.
    }
    // parse.c:639-643 — skip leading command separators; a SEPER on a fresh
    // newline at the top level (endtok == ENDINPUT) is an EMPTY command — the
    // bare-Enter case — so return None WITHOUT pulling another input line.
    // Missing this, `parse_program_until` treated the trailing newline as an
    // incomplete list and read a continuation line, so every empty Enter (and
    // the line after it) rendered the PS2 `>` prompt instead of PS1.
    while tok() == SEPER {
        if isnewlin() > 0 {
            clear_hdocs();
            return None;
        }
        zshlex();
    }
    if tok() == ENDINPUT {
        return None;
    }
    // single_event = TRUE: one logical command line per parse_event, the
    // faithful port of C par_event's endtok==ENDINPUT top-level mode
    // (parse.c:635). loop() reads+executes ONE event at a time so `-v`/`-x`
    // echo and runtime `setopt verbose`/`xtrace` interleave with execution
    // exactly as zsh does — whole-program parsing can't (it finishes
    // parsing before any execution).
    //
    // Enabling this required isolating the runtime nested-parse machinery
    // from the now-mid-stream outer reader (the parse/execute interleave
    // exposed three split-global hazards that whole-program mode hid):
    //   * cmd-subst / proc-sub / eval / source bodies re-parse via
    //     vm_helper::parse_isolated (the AST-path bridge for C's
    //     parse_string, exec.c:283) — it sets `strin` so a drained nested
    //     buffer EOFs instead of STEALING the outer reader's next SHIN line.
    //   * strinbeg/strinend now bump BOTH `strin` copies (hist.rs + the
    //     input.rs one ingetc checks); lexinit zeroes BOTH `lexstop` copies
    //     — C has a single global for each, zshrs split them.
    //   * loop() saves/restores LEX_LINENO across execode (init.rs), the
    //     execlist `oldlineno` discipline (exec.c:28/292), so per-statement
    //     SET_LINENO doesn't freeze `$LINENO` for the next event.
    let mut program = parse_program_until(None, true);
    // c:622-625 `if (!par_event(endtok)) { clear_hdocs(); return NULL; }` —
    // par_event sets `tok = LEXERR` on a syntax error (c:670-682) and returns
    // 0 (c:686-689), so a failed event yields NULL even when lists before the
    // error parsed. loop() then sees "no program" + LEXERR and, reading a
    // shell's stdin at top level, keeps reading (c:Src/init.c:171).
    if program.lists.is_empty() || tok() == LEXERR {
        clear_hdocs();
        return None;
    }
    // parse.c:630 bld_eprog post-pass — wire heredoc bodies collected
    // by zshlex into the ZshRedir nodes (mirror of `parse()`).
    let bodies: Vec<HereDocInfo> = LEX_HEREDOCS
        .with_borrow(|v| v.clone())
        .into_iter()
        .map(|h| HereDocInfo {
            content: h.content,
            terminator: h.terminator,
            quoted: h.quoted,
        })
        .collect();
    if !bodies.is_empty() {
        fill_heredoc_bodies(&mut program, &bodies);
    }
    Some(program)
}

/// Port of `par_event()` from `Src/parse.c:635`.
///
/// ```text
/// event : ENDINPUT
///       | SEPER
///       | sublist [ SEPER | AMPER | AMPERBANG ]
/// ```
///
/// Returns 1/true when an event (or the closing `endtok`) was parsed. A
/// sublist followed by anything but a separator, `endtok` or ENDINPUT is
/// a syntax error: `tok` becomes LEXERR and the error is reported here.
///
/// !!! WARNING: AST, NOT WORDCODE !!! C emits the list code with
/// `ecadd`/`set_list_code` (c:649-668) and patches `Z_END` into the last
/// one (c:688); this port drives the AST `par_sublist` and keeps only the
/// token walk and the error handling. Its one caller, `parse_event` with a
/// closing token (skipcomm's `parse_event(OUTPAR)`), throws the program
/// away, as C does with `dummy_eprog` (c:626-629).
pub fn par_event(endtok: lextok) -> bool {
    // c:639-643
    while tok() == SEPER {
        if isnewlin() > 0 && endtok == ENDINPUT {
            return false;
        }
        zshlex();
    }
    // c:644-647
    if tok() == ENDINPUT {
        return false;
    }
    if tok() == endtok {
        return true;
    }

    // c:651-669
    let mut r = false;
    if par_sublist().is_some() {
        let t = tok();
        if t == ENDINPUT || t == endtok {
            r = true; // c:652-654
        } else if t == SEPER {
            // c:655-659
            if isnewlin() <= 0 || endtok != ENDINPUT {
                zshlex();
            }
            r = true;
        } else if t == AMPER || t == AMPERBANG {
            zshlex(); // c:660-668
            r = true;
        }
    }
    if !r {
        // c:670-682
        set_tok(LEXERR);
        if errflag.load(Ordering::Relaxed) != 0 {
            yyerror(0);
            return false;
        }
        yyerror(1);
        crate::ported::hist::herrflush();
        if *crate::ported::utils::noerrs_lock().lock().unwrap() != 2 {
            errflag.fetch_or(ERRFLAG_ERROR, Ordering::Relaxed);
        }
        return false;
    }
    // c:684-691
    if !par_event(endtok) {
        return errflag.load(Ordering::Relaxed) == 0;
    }
    true
}

/// Port of `parse_list()` from `Src/parse.c:697` — C signature `parse_list(void)`. C-shape entry
/// point: drives `par_list` and finalizes via `bld_eprog`. Returns
/// `None` on syntax error.
pub fn parse_list() -> Option<eprog> {
    // c:697
    set_tok(ENDINPUT);
    init_parse();
    zshlex();
    // c:Src/parse.c:705 — `par_list(&c);` emits wordcode for the
    // full multi-statement list (its goto-rec loop walks all
    // SEPER-separated sublists). The Rust AST par_list() emits
    // NOTHING to the wordcode buffer (only builds the AST), so
    // bld_eprog returned an empty program AND tok stayed at
    // SEPER, tripping the syntax-error check below for any
    // \`cmd; cmd\` body.
    //
    // Route through par_event_wordcode (the wordcode emitter,
    // lines 4395+) which mirrors C's par_list loop semantics
    // and populates the wordcode buffer that bld_eprog reads.
    let _start = par_event_wordcode();
    if tok() != ENDINPUT {
        clear_hdocs();
        set_tok(LEXERR);
        // c:Src/parse.c:708 — `yyerror(0);`. C-faithful invocation;
        // the message format ("parse error near `X'") is built
        // inside yyerror from zshlextext/tokstr().
        yyerror(0);
        return None;
    }
    Some(bld_eprog(false))
}

/// Port of `parse_cond()` from `Src/parse.c:722` — C signature `parse_cond(void)`. Only used by
/// `bin_test`/`bin_bracket` for `/bin/test`/`[` compat — the
/// `condlex` global must already point at `testlex` before entry.
pub fn parse_cond() -> Option<eprog> {
    // c:722
    init_parse();
    // `par_cond_top` is C's wordcode `par_cond` (c:2409); the bare name is
    // taken by the `[[ ]]` AST parser in this file.
    if par_cond_top() == 0 {
        clear_hdocs();
        return None;
    }
    Some(bld_eprog(true))
}

// ============================================================
// Wordcode emission helpers (parse.c private helpers)
//
// Direct ports of zsh's wordcode-emission helpers in parse.c.
// These write u32 opcodes into a flat `ecbuf` array thread-local
// via ecadd / ecdel / ecispace / ecstrcode and friends. The
// par_*_wordcode family at parse.rs:1700-3500 walks the lex
// stream and emits a real wordcode buffer here.
//
// (The AST tree built by par_program / par_simple / etc. is a
// separate path used by fusevm; see compile_zsh.rs for the AST
// → fusevm-bytecode compiler.)
// ============================================================

/// Patch a list-placeholder wordcode with its actual opcode +
/// jump distance. Direct port of zsh/Src/parse.c:738
/// `set_list_code`. zsh emits an `ecadd(0)` placeholder before
/// par_sublist runs, then comes back through set_list_code to
/// rewrite the slot with WCB_LIST(type, distance) once the
/// sublist's final length is known.
///
/// Port of `set_list_code()` from `Src/parse.c:738` — C signature `set_list_code(int p, int type, int cmplx)`.
/// Patches the WCB_LIST header at `p` based on
/// whether the sublist body is simple (single command, no
/// pipeline) and Z_SYNC/Z_END — emits the Z_SIMPLE-optimized
/// header when possible, otherwise the plain WCB_LIST(type, 0).
pub fn set_list_code(p: usize, type_code: i32, cmplx: bool) {
    let _ = wc_bdata;
    // c:740 — `if (!cmplx && (type == Z_SYNC || type == (Z_SYNC | Z_END))
    // && WC_SUBLIST_TYPE(ecbuf[p+1]) == WC_SUBLIST_END)`
    let sublist_code = ECBUF.with_borrow(|b| b.get(p + 1).copied().unwrap_or(0));
    let z = type_code;
    let qualifies = !cmplx
        && (z == Z_SYNC || z == (Z_SYNC | Z_END))
        && WC_SUBLIST_TYPE(sublist_code) == WC_SUBLIST_END;
    if qualifies {
        // c:742 — `int ispipe = !(WC_SUBLIST_FLAGS(ecbuf[p+1])
        // & WC_SUBLIST_SIMPLE);`
        let ispipe = (WC_SUBLIST_FLAGS(sublist_code) & WC_SUBLIST_SIMPLE) == 0;
        // c:743 — `ecbuf[p] = WCB_LIST((type|Z_SIMPLE), ecused-2-p);`
        let used = ECUSED.get() as usize;
        let off = used.saturating_sub(2 + p);
        ECBUF.with_borrow_mut(|b| {
            if p < b.len() {
                b[p] = WCB_LIST((z | Z_SIMPLE) as wordcode, off as wordcode);
            }
        });
        // c:744 — `ecdel(p+1);`
        ecdel(p + 1);
        // c:745-746 — `if (ispipe) ecbuf[p+1] = WC_PIPE_LINENO(ecbuf[p+1]);`
        if ispipe {
            ECBUF.with_borrow_mut(|b| {
                if p + 1 < b.len() {
                    b[p + 1] = WC_PIPE_LINENO(b[p + 1]);
                }
            });
        }
    } else {
        // c:748 — `ecbuf[p] = WCB_LIST(type, 0);`
        ECBUF.with_borrow_mut(|b| {
            if p < b.len() {
                b[p] = WCB_LIST(z as wordcode, 0);
            }
        });
    }
}

/// Port of `set_sublist_code()` from `Src/parse.c:755` — C signature `set_sublist_code(int p, int type, int flags, int skip, int cmplx)`.
/// Patches the WCB_SUBLIST header at `p`.
/// When the sublist is non-complex (single command, no pipeline),
/// sets WC_SUBLIST_SIMPLE and rewrites the following slot to
/// `WC_PIPE_LINENO`.
pub fn set_sublist_code(p: usize, type_code: i32, flags: i32, skip: i32, cmplx: bool) {
    if cmplx {
        // c:758 — `ecbuf[p] = WCB_SUBLIST(type, flags, skip);`
        ECBUF.with_borrow_mut(|b| {
            if p < b.len() {
                b[p] = WCB_SUBLIST(type_code as wordcode, flags as wordcode, skip as wordcode);
            }
        });
    } else {
        // c:760 — `ecbuf[p] = WCB_SUBLIST(type, flags|WC_SUBLIST_SIMPLE, skip);`
        ECBUF.with_borrow_mut(|b| {
            if p < b.len() {
                b[p] = WCB_SUBLIST(
                    type_code as wordcode,
                    (flags as wordcode) | WC_SUBLIST_SIMPLE,
                    skip as wordcode,
                );
            }
        });
        // c:761 — `ecbuf[p+1] = WC_PIPE_LINENO(ecbuf[p+1]);`
        ECBUF.with_borrow_mut(|b| {
            if p + 1 < b.len() {
                b[p + 1] = WC_PIPE_LINENO(b[p + 1]);
            }
        });
    }
}

/// Parse a list (sublist with optional & or ;).
///
/// Port of `par_list()` from `Src/parse.c:771` (body c:771-804; the
/// `par_list1` wrapper follows at c:808).
///
/// **Structural divergence**: zsh's parse.c emits flat wordcode
/// into the `ecbuf` u32 array via `ecadd(0)` (placeholder),
/// `set_list_code(p, code, complexity)`, `wc_bdata(Z_END)`. zshrs
/// builds an AST node `ZshList { sublist, flags }` instead. The
/// async/sync/disown discrimination at parse.c:785-790 maps to
/// zshrs's `ListFlags { async_, disown }` field — Z_SYNC is the
/// default (no flags), Z_ASYNC = `&` = `async_=true`, Z_DISOWN +
/// Z_ASYNC = `&!`/`&|` = both true. Same semantics, different
/// representation. This divergence is repository-wide: every
/// `par_*` function emits wordcode in C, every `parse_*` builds
/// AST in Rust. The compile_zsh module then traverses the AST to
/// emit fusevm bytecode, which serves the same role as zsh's
/// wordcode but with a different opcode set and execution model.
fn par_list(single_event: bool) -> Option<(ZshList, bool)> {
    let sublist = par_sublist()?;

    // c:769-803 — `list : { SEPER } [ sublist [ { SEPER | AMPER |
    // AMPERBANG } list ] ]`. The second tuple element reports
    // whether the list ended with an EXPLICIT terminator. C's list
    // grammar only chains sublists across SEPER/AMPER/AMPERBANG; a
    // sublist followed directly by another command (`{a} {b}`) ends
    // the list and the dangling token is the CALLER's problem
    // (par_while takes a dangling INBRACE as the loop body, par_event
    // yyerrors at c:671-680). parse_program_until needs this bit to
    // reproduce that split.
    let (flags, terminated) = match tok() {
        AMPER => {
            zshlex();
            (
                ListFlags {
                    async_: true,
                    disown: false,
                },
                true,
            )
        }
        AMPERBANG => {
            zshlex();
            (
                ListFlags {
                    async_: true,
                    disown: true,
                },
                true,
            )
        }
        SEPER => {
            // c:Src/parse.c par_event SEPER branch — `if (isnewlin <= 0
            // || endtok != ENDINPUT) zshlex();`. The lexer folds both
            // `;` and `\n` into SEPER (lex.rs:265), distinguishing them
            // via LEX_ISNEWLIN (C `isnewlin`). At a TOP-LEVEL event
            // boundary (single_event ≈ endtok == ENDINPUT) a SEPER that
            // was a NEWLINE terminates the event and is NOT consumed —
            // it's left for the next parse_event, whose leading skip
            // reads the following line only THEN. That's what lets
            // loop() read+execute one event at a time so `-v`/`-x` echo
            // and runtime `setopt verbose` interleave with execution
            // like zsh. A `;` SEPER (isnewlin <= 0), or any SEPER inside
            // a body / whole-program parse (single_event = false), is
            // consumed to chain the next sublist.
            let is_newline = crate::ported::lex::LEX_ISNEWLIN.with(|c| c.get()) > 0;
            if !(single_event && is_newline) {
                zshlex();
            }
            (ListFlags::default(), true)
        }
        SEMI | NEWLIN => {
            // Unfolded `;` / preserved newline (LEXFLAGS_NEWLINE) — not a
            // top-level event terminator; consume and continue.
            zshlex();
            (ListFlags::default(), true)
        }
        _ => (ListFlags::default(), false),
    };

    Some((ZshList { sublist, flags }, terminated))
}

/// Port of `par_list1()` from `Src/parse.c:808`.
/// Parse one list — non-recursing variant. Like par_list but
/// doesn't recurse on the trailing-separator path; used by
/// callers that only want one statement (e.g. each arm of a
/// case body).
pub fn par_list1() -> Option<ZshSublist> {
    // parse.c:810-816 — body is a single par_sublist call wrapped
    // in the eu/ecused tracking that zshrs doesn't need (no
    // wordcode buffer).
    par_sublist()
}

/// Parse a sublist (pipelines connected by && or ||).
///
/// Port of `par_sublist()` from `Src/parse.c:825` (with `par_sublist2`
/// at c:869-892 folded in). par_sublist handles the
/// && / || conjunction and emits WC_SUBLIST opcodes; par_sublist2
/// handles the leading `!` negation and `coproc` keyword.
///
/// AST mapping: ZshSublist { pipe, conj_chain }, where `conj_chain`
/// is a Vec<(ConjOp, ZshSublist)> for chained && / ||. C uses
/// flat wordcode with WC_SUBLIST_AND / WC_SUBLIST_OR markers.
fn par_sublist() -> Option<ZshSublist> {
    let mut flags = SublistFlags::default();

    // Handle coproc and !
    if tok() == COPROC {
        flags.coproc = true;
        zshlex();
    } else if tok() == BANG_TOK {
        flags.not = true;
        zshlex();
    }

    // c:882-883 (par_sublist2) — `if (!par_pline(cmplx) && !f) return -1;`:
    // after `coproc` or `!` a missing pipeline is not an error, so `{ ! }`,
    // `( ! )` and `fn() { ! }` parse, and the empty pipeline runs as a null
    // command (status 0, negated to 1). An error par_pline itself raised
    // still fails the sublist.
    let errflag_before = crate::ported::utils::errflag.load(std::sync::atomic::Ordering::Relaxed);
    let pipe = match par_pline() {
        Some(p) => p,
        // A `|` / `|&` with no command before it is still an error, reported
        // by the caller at that token (`{ ! | }` → "parse error near `|'").
        None if (flags.not || flags.coproc)
            && !matches!(tok(), BAR_TOK | BARAMP)
            && crate::ported::utils::errflag.load(std::sync::atomic::Ordering::Relaxed)
                == errflag_before =>
        {
            ZshPipe {
                cmd: ZshCommand::Simple(ZshSimple {
                    assigns: Vec::new(),
                    words: Vec::new(),
                    redirs: Vec::new(),
                    typeset_reswd: false,
                    via_alias: None,
                }),
                next: None,
                lineno: toklineno(),
                merge_stderr: false,
            }
        }
        None => return None,
    };

    // Check for && or ||
    let next = match tok() {
        DAMPER => {
            zshlex();
            if !crate::dash_mode::dash_skip_operator_separators() {
                return None;
            }
            // c:Src/parse.c:par_sublist — and-or operators (`&&`,
            // `||`) require a sublist on each side. After consuming
            // `&&`/`||`, another and-or operator OR a pipe-operator
            // immediately after is a parse error in C zsh. zshrs's
            // recursion silently returned None and dropped the
            // operator. Bug #171 in docs/BUGS.md.
            if matches!(tok(), DAMPER | DBAR | BAR_TOK | BARAMP) {
                let name = match tok() {
                    DAMPER => "&&",
                    DBAR => "||",
                    BAR_TOK => "|",
                    BARAMP => "|&",
                    _ => "operator",
                };
                zerr(&format!("parse error near `{}'", name));
                return None;
            }
            par_sublist().map(|s| (SublistOp::And, Box::new(s)))
        }
        DBAR => {
            zshlex();
            if !crate::dash_mode::dash_skip_operator_separators() {
                return None;
            }
            if matches!(tok(), DAMPER | DBAR | BAR_TOK | BARAMP) {
                let name = match tok() {
                    DAMPER => "&&",
                    DBAR => "||",
                    BAR_TOK => "|",
                    BARAMP => "|&",
                    _ => "operator",
                };
                zerr(&format!("parse error near `{}'", name));
                return None;
            }
            par_sublist().map(|s| (SublistOp::Or, Box::new(s)))
        }
        _ => None,
    };

    Some(ZshSublist { pipe, next, flags })
}

/// Port of `par_sublist2()` from `Src/parse.c:869` — C signature `par_sublist2(int *cmplx)`.
/// Secondary-sublist arm: handles the `COPROC`/`Bang` prefix
/// in front of a pline. Returns the WC_SUBLIST flag word added.
pub fn par_sublist2(cmplx: &mut i32) -> Option<i32> {
    // c:870 — `int f = 0;`
    let mut f: i32 = 0;
    // c:873-880 — COPROC / BANG prefix flags.
    if tok() == COPROC {
        *cmplx = 1;
        f |= WC_SUBLIST_COPROC as i32;
        zshlex();
    } else if tok() == BANG_TOK {
        *cmplx = 1;
        f |= WC_SUBLIST_NOT as i32;
        zshlex();
    }
    // c:882-883 — `if (!par_pline(cmplx) && !f) return -1;`
    if !par_pipe_wordcode(cmplx) && f == 0 {
        return None;
    }
    // c:885 — `return f;`
    Some(f)
}

/// Port of `par_pline()` from `Src/parse.c:894`.
/// Parse a pipeline (cmds joined by `|` / `|&`).
/// AST: ZshPipe { cmds: Vec<ZshCommand> }.
/// C emits WC_PIPE wordcodes per command; same flow.
fn par_pline() -> Option<ZshPipe> {
    let lineno = toklineno();
    let cmd = par_cmd(false)?;

    // Check for | or |&
    let mut merge_stderr = false;
    let next = match tok() {
        BAR_TOK | BARAMP => {
            merge_stderr = tok() == BARAMP;
            zshlex();
            if !crate::dash_mode::dash_skip_operator_separators() {
                return None;
            }
            // c:Src/parse.c:par_pline — pipe-operators require a
            // command on each side. After consuming `|`/`|&`,
            // C zsh's recursive par_pline call returns -1 (parse
            // error) when the next token is another pipe-operator
            // — `a | | b` errors with `parse error near `|''`.
            // zshrs's `par_pline()?` silently returned None on
            // missing command, dropping the rest of the input
            // without diagnosing the empty-pipe-operand. Bug #171
            // in docs/BUGS.md.
            if matches!(tok(), BAR_TOK | BARAMP) {
                let name = if tok() == BARAMP { "|&" } else { "|" };
                zerr(&format!("parse error near `{}'", name));
                return None;
            }
            // c:914-916 — `if (!par_pline(cmplx)) { tok = LEXERR; }`: a
            // `|` with no command after it (`print a |` at end of input)
            // is a syntax error, not a one-stage pipeline. Returning the
            // bare `None` let the left side parse and RUN.
            let rest = par_pline();
            if rest.is_none() {
                set_tok(LEXERR);
            }
            rest.map(Box::new)
        }
        _ => None,
    };

    Some(ZshPipe {
        cmd,
        next,
        lineno,
        merge_stderr,
    })
}

/// Port of `par_cmd()` from `Src/parse.c:958` — C signature `par_cmd(int *cmplx, int zsh_construct)`.
/// Parse a command — dispatches by leading token (FOR / CASE /
/// IF / WHILE / UNTIL / REPEAT / FUNC / DINBRACK / DINPAR /
/// Inpar subshell / Inbrace current-shell / TIME / NOCORRECT,
/// else simple). Direct port of zsh/Src/parse.c:958 `par_cmd`.
fn par_cmd(zsh_construct: bool) -> Option<ZshCommand> {
    // Parse leading redirections
    let mut redirs = Vec::new();
    while IS_REDIROP(tok()) {
        if let Some(redir) = par_redir() {
            redirs.push(redir);
        }
    }
    // c:964-969 — the leading redirections belong to WHATEVER command
    // follows, compound or simple: `>| f { print x ;}` captures the group
    // (Src/subst.c:1993 builds exactly that for `${ … }`). par_simple takes
    // them itself; a compound form gets them ahead of its trailing ones.
    let mut leading = Some(redirs);

    // c:Src/parse.c:970-1030 par_cmd — push the open construct onto the
    // cmdstack for the duration of its sub-parse, then pop. The cmdstack
    // drives `%_` prompt expansion, so this is what makes a multi-line
    // construct's PS2 render `for> ` / `while> ` / `case> ` across
    // continuation lines instead of a bare `> `. (The cmdstack does NOT
    // drive tokenization in zshrs — the lexer's only reads are the
    // debug-only DPUTS "cmdstack not empty" asserts — so wrapping the AST
    // dispatch is behaviorally inert outside the prompt.) IF is excluded
    // to match C, where par_if manages its own cmdstack (CS_IF/CS_IFTHEN);
    // DINPAR/TIME/INOUTPAR are not cmdstack constructs in C either.
    let cmd = match tok() {
        FOR => {
            cmdpush(CS_FOR as u8); // c:972
            let c = par_for();
            cmdpop(); // c:974
            c
        }
        FOREACH => {
            cmdpush(CS_FOREACH as u8); // c:977
            let c = par_for();
            cmdpop(); // c:979
            c
        }
        SELECT => {
            cmdpush(CS_SELECT as u8); // c:983
            let c = parse_select();
            cmdpop(); // c:985
            c
        }
        CASE => {
            cmdpush(CS_CASE as u8); // c:988
            let c = par_case();
            cmdpop(); // c:990
            c
        }
        IF => par_if(), // c:992-994 — par_if manages its own cmdstack
        WHILE => {
            cmdpush(CS_WHILE as u8); // c:996
            let c = par_while(false);
            cmdpop(); // c:998
            c
        }
        UNTIL => {
            cmdpush(CS_UNTIL as u8); // c:1001
            let c = par_while(true);
            cmdpop(); // c:1003
            c
        }
        REPEAT => {
            cmdpush(CS_REPEAT as u8); // c:1006
            let c = par_repeat();
            cmdpop(); // c:1008
            c
        }
        INPAR_TOK => {
            cmdpush(CS_SUBSH as u8); // c:1012
            let c = par_subsh(zsh_construct);
            cmdpop(); // c:1014
            c
        }
        INOUTPAR => parse_anon_funcdef(),
        INBRACE_TOK => {
            cmdpush(CS_CURSH as u8); // c:1017
            let c = parse_cursh(zsh_construct);
            cmdpop(); // c:1019
            c
        }
        FUNC => {
            cmdpush(CS_FUNCDEF as u8); // c:1022
            let c = par_funcdef();
            cmdpop(); // c:1024
            c
        }
        DINBRACK => {
            cmdpush(CS_COND as u8); // c:1027
            let c = par_cond();
            cmdpop(); // c:1029
            c
        }
        DINPAR => parse_arith(),
        TIME => par_time(),
        _ => par_simple(leading.take().unwrap_or_default()),
    };
    let leading = leading.unwrap_or_default();

    // Parse trailing redirections. For Simple commands the redirs were
    // already captured inside par_simple; for compound forms (Cursh,
    // Subsh, If, While, etc.) we collect them here and wrap in
    // ZshCommand::Redirected so compile_zsh can scope-bracket them.
    if let Some(inner) = cmd {
        let mut trailing: Vec<ZshRedir> = leading;
        while IS_REDIROP(tok()) {
            if let Some(redir) = par_redir() {
                trailing.push(redir);
            }
        }
        // c:Src/parse.c:par_cmd — compound forms (Cursh `{...}`, Subsh
        // `(...)`, If/While/Until/For/Case/Select/Repeat/Funcdef) must
        // be followed by a valid sublist/list separator (`;`, `\n`,
        // `&`, `|`, `&&`, `||`, redirect-op) — STRING_LEX after a
        // compound is a parse error. zshrs's outer par_list loop
        // silently treated trailing words as a new command, masking
        // syntax errors like `{ echo a; } b c`. Mirror C's strict
        // post-compound terminator check. Bug #146 in docs/BUGS.md.
        // With zsh_construct set (an anonymous function's `( … )` / `{ … }`
        // body, c:2114) the words that follow are that function's arguments
        // (c:2148-2167), not a stray word after a compound command.
        if !zsh_construct
            && !matches!(inner, ZshCommand::Simple(_))
            && tok() == STRING_LEX
            && COND_LIST_DEPTH.with(|d| d.get()) == 0
        {
            // c:Src/parse.c:2738 — the error token is `zshlextext`, the
            // human-readable source text, so quotes/sigils are shown
            // verbatim (`"quoted"`, `'x'`, `$var`). zshrs's `tokstr()`
            // still carries the inline quote MARKERS (Dnull/Snull/Stringg
            // = `\u{e19e}`/`\u{e19d}`/`\u{e185}`); emitting it raw printed the
            // marker bytes and dropped the visible quotes. Untokenize to
            // the display form: Dnull→`"`, Snull→`'`, Stringg→`$`, Bnull→`\`.
            let bad = crate::ported::lex::untokenize_preserve_quotes(&tokstr().unwrap_or_default());
            zerr(&format!("parse error near `{}'", bad));
            // Reset state before returning so the outer loop's None
            // detection unwinds cleanly.
            set_incmdpos(true);
            set_incasepat(0);
            set_incond(0);
            set_intypeset(false);
            return None;
        }
        // c:1072-1075 — every par_cmd tail resets the lexer state
        // toggles so the NEXT command starts in cmd position with
        // case/cond/typeset off. par_simple/par_cond set `incmdpos=0`
        // during their bodies; without this reset the next iteration
        // of the outer par_list loop sees `if` / `done` / `select`
        // etc. as plain strings and the AST collapses.
        set_incmdpos(true);
        set_incasepat(0);
        set_incond(0);
        set_intypeset(false);
        if trailing.is_empty() {
            return Some(inner);
        }
        // Simple already absorbed its own redirs (compile path expects
        // them on ZshSimple), so don't double-wrap.
        if matches!(inner, ZshCommand::Simple(_)) {
            if let ZshCommand::Simple(mut s) = inner {
                s.redirs.extend(trailing);
                return Some(ZshCommand::Simple(s));
            }
            unreachable!()
        }
        return Some(ZshCommand::Redirected(Box::new(inner), trailing));
    }
    // Same reset on the empty-cmd branch (mirror c:1072 unconditional
    // path — the C function only returns 0 above when the dispatch
    // produced no command, and falls through to the reset block).
    set_incmdpos(true);
    set_incasepat(0);
    set_incond(0);
    set_intypeset(false);

    None
}

/// Port of `par_for()` from `Src/parse.c:1087`.
/// Parse `for NAME in WORDS; do BODY; done` (foreach style) AND
/// `for ((init; cond; incr)) do BODY done` (c-style).
/// parse_for_cstyle is the
/// inner branch for the `((...))` arithmetic-header variant
/// (parse.c:1100-1140 inside par_for).
fn par_for() -> Option<ZshCommand> {
    let is_foreach = tok() == FOREACH;
    // c:1094-1095 (Src/parse.c, par_for) — set `infor=2` (only when
    // tok==FOR) so the lexer's `(` peek at lex.c:784-789
    // (`if (infor) { ... return DINPAR; }`) routes the arith-for
    // body through dbparens semicolon-splitting instead of the
    // `cmd_or_math` whole-body capture path. Without this, `for ((
    // i=0; i<3; i++ ))` lexed as a single `((arith))` expression
    // and parse_for_cstyle's second zshlex got an empty/wrong tok.
    //
    // Guard the loop-variable read against alias expansion and
    // spell-correction. C uses `incmdpos = 0` for the first name
    // (c:1094) plus `noaliases = nocorrect = 1` for the rest
    // (c:1123), restoring them at c:1137. We guard the WHOLE name
    // read with `noaliases`/`nocorrect` (the actual anti-alias
    // mechanism) and leave `incmdpos` untouched: without this, a
    // user `alias i='if [[ … ]]; then … fi'` (real zpwr config,
    // set by zpwrBindAliasesZshLate) makes `for i in {0..$#}`
    // expand the loop variable `i` into `if`, so par_for's next
    // token is IF instead of the STRING name and it dies with
    // "expected variable name in for". Forcing incmdpos=0 here
    // (as C does) instead regresses the `(`/`((`/`do` detection
    // for for-paren, arith-for and the loop body, which this
    // parser recovers from the inherited command position.
    let saved_noaliases = noaliases();
    let saved_nocorrect = nocorrect();
    set_noaliases(true);
    set_nocorrect(1);
    set_infor(if tok() == FOR { 2 } else { 0 }); // c:1095
    zshlex(); // c:1096

    // Check for C-style: for (( init; cond; step ))
    if tok() == DINPAR {
        // c:1110-1111 — close out infor / cmdpos after parse_for_cstyle
        // has consumed the init/cond/step triple. Done inside the
        // helper itself so we honour the C ordering.
        set_noaliases(saved_noaliases);
        set_nocorrect(saved_nocorrect);
        return parse_for_cstyle();
    }

    // c:1116 — `infor = 0;` immediately on entering the foreach
    // branch. Without this, `infor` stays at 2 (set at c:1095 when
    // tok==FOR) for the rest of par_for, and the lexer's `((`
    // peek at lex.c:786 routes every subsequent `((...))` inside
    // the loop body through dbparens — so `for x in a; do (( 1
    // )); done` and `if (( 1 )) { … }` inside the do-body both
    // mis-lexed as a c-style for header.
    set_infor(0); // c:1116

    // Get variable name(s). zsh parse.c par_for accepts multiple
    // identifier tokens before `in`/`(`/newline — `for k v in ...`
    // assigns each iteration's pair of values to k and v in turn.
    // We store the names space-joined since variable identifiers
    // can't contain whitespace.
    //
    // c:1123-1131 — C's shape is a `for(;;)` whose FIRST iteration takes
    // the current token unconditionally and only THEN tests the next one:
    //     for (;;) { n++; ecstr(tokstr); zshlex();
    //                if (tok != STRING || !strcmp(tokstr, "in") || sel) break;
    //                if (!isident(tokstr) || errflag) YYERRORV(oecused); }
    // So the loop variable may itself be spelled `in` — `for in in in in
    // in stop` iterates $in over `in in in stop` (A01grammar.ztst:292).
    // The old Rust loop tested `v == "in"` BEFORE taking the first name,
    // so that form died with "expected variable name in for".
    let mut names: Vec<String> = Vec::new();
    // c:1117-1118 — `if (tok != STRING || !isident(tokstr)) YYERRORV(oecused);`
    // — the FIRST name must be an identifier (`for a-b in x` is an error).
    if tok() == STRING_LEX && crate::ported::params::isident(&tokstr().unwrap_or_default()) {
        loop {
            names.push(tokstr().unwrap_or_default()); // c:1124 ecstr(tokstr)
            zshlex(); // c:1125
                      // c:1126 — `if (tok != STRING || !strcmp(tokstr, "in") || sel) break;`
            if tok() != STRING_LEX {
                break;
            }
            let v = tokstr().unwrap_or_default();
            if v == "in" {
                break;
            }
            // c:1127-1132 — C YYERRORs on a non-identifier here. The Rust
            // lexer can hand back the `(word1 word2)` list of the
            // `for x (…)` form as a single Inpar-wrapped STRING (see the
            // list reader below), so stop the name scan instead of
            // erroring and let that reader handle it.
            if !crate::ported::params::isident(&v) {
                break;
            }
        }
    }
    // c:1137-1138 — restore alias / spell-correct state now the
    // name list is fully read (the `in`/`(` list that follows must
    // lex with the caller's normal settings).
    set_noaliases(saved_noaliases);
    set_nocorrect(saved_nocorrect);
    if names.is_empty() {
        // c:1117-1118 — `YYERRORV(oecused)` only flags LEXERR; the single
        // "parse error near `<zshlextext>'" comes from par_event's yyerror.
        set_tok(LEXERR); // c:87 `tok = LEXERR`
        return None;
    }
    let var = names.join(" ");

    // Skip newlines
    skip_separators();

    // Get list. The lexer-port quirk: `for x (a b c)` arrives as a
    // single String token with the parens lexed-as-content
    // (`<Inpar>a b c<Outpar>`) instead of as separate Inpar/String/
    // Outpar tokens. Detect that shape and split it manually.
    let list = if tok() == STRING_LEX
        && tokstr()
            .map(|s| s.starts_with('\u{e188}') && s.ends_with('\u{e18a}'))
            .unwrap_or(false)
    {
        let raw = tokstr().unwrap_or_default();
        // Strip leading Inpar + trailing Outpar. KEEP the inner
        // content tokenized — `for x ({1..3}) …` has `{1..3}` as
        // Inbrace+content+Outbrace markers, which compile_word_str
        // needs to detect and brace-expand. Untokenizing here would
        // collapse the markers to plain `{` `}` chars and the brace-
        // expansion pass (which strictly requires Inbrace TOKEN per
        // Src/glob.c:hasbraces) would skip the word entirely.
        // Split only on UNTOKENIZED whitespace at the top level —
        // tokenized characters (TOKEN range \u{e184}..\u{e1a1}) are part
        // of one word; bare ASCII spaces / tabs separate words.
        let inner = &raw[raw.char_indices().nth(1).map(|(i, _)| i).unwrap_or(0)
            ..raw
                .char_indices()
                .last()
                .map(|(i, _)| i)
                .unwrap_or(raw.len())];
        let mut words: Vec<String> = Vec::new();
        let mut cur = String::new();
        for c in inner.chars() {
            if c == ' ' || c == '\t' || c == '\n' {
                if !cur.is_empty() {
                    words.push(std::mem::take(&mut cur));
                }
            } else {
                cur.push(c);
            }
        }
        if !cur.is_empty() {
            words.push(cur);
        }
        zshlex();
        ForList::Words(words)
    } else if tok() == STRING_LEX {
        let s = tokstr();
        if s.map(|s| s == "in").unwrap_or(false) {
            // c:Src/parse.c:1147-1154 — after consuming `in`, the
            // for-list reads in WORD position, not command position.
            // Reset incmdpos=false so the lexer's LX2_INBRACE arm
            // (lex.rs:1791) treats a leading `{` as the brace-
            // expansion marker (`bct++; add(Inbrace)`) instead of
            // returning STRING("{") + promoting to INBRACE_TOK.
            // Without this, `for i in {1..3}` saw `{` as the body-
            // opener brace, so the word-collection loop got an
            // empty word list and the loop body silently ran 0
            // iterations.
            set_incmdpos(false);
            zshlex();
            let mut words = Vec::new();
            while tok() == STRING_LEX {
                let _ts_s = tokstr();
                if let Some(s) = _ts_s.as_deref() {
                    words.push(s.to_string());
                }
                zshlex();
            }
            // c:1149-1150 — `if (tok != SEPER) YYERRORV(oecused);` — the
            // word list must end at a separator (`for x in a b` at end of
            // input is an error).
            if tok() != SEPER {
                set_tok(LEXERR); // c:87 `tok = LEXERR`
                return None;
            }
            // c:Src/parse.c:1162 — `incmdpos = 1;` after the
            // wordlist + SEPER are consumed, so the next token
            // (`do` / `{` body opener) lexes at command position.
            set_incmdpos(true);
            ForList::Words(words)
        } else {
            ForList::Positional
        }
    } else if tok() == INPAR_TOK {
        // for var (...) — `for x ({1..3})`: inside the parens, the
        // list is in WORD position so `{` must lex as the brace-
        // expansion Inbrace marker, NOT as a body-opener INBRACE_TOK.
        // Without resetting incmdpos before the next zshlex, the
        // lexer's LX2_INBRACE arm promotes `{` to INBRACE_TOK and
        // the word-collection loop exits empty, giving
        // `for x ({1..3})` an empty iteration.
        set_incmdpos(false);
        zshlex();
        let mut words = Vec::new();
        while tok() == STRING_LEX || tok() == SEPER {
            if tok() == STRING_LEX {
                let _ts_s = tokstr();
                if let Some(s) = _ts_s.as_deref() {
                    words.push(s.to_string());
                }
            }
            zshlex();
        }
        // c:1158-1159 — `if (tok != OUTPAR) YYERRORV(oecused);`
        if tok() != OUTPAR_TOK {
            set_tok(LEXERR); // c:87 `tok = LEXERR`
            return None;
        }
        // After the `)` of a for-list, the next token is the
        // body opener — `do`/`{`. zsh's lexer needs incmdpos
        // set so `{` lexes as Inbrace (not as a literal). C
        // analogue: parse.c::par_for sets `incmdpos = 1`
        // after consuming the Outpar before the body parse.
        set_incmdpos(true);
        zshlex();
        ForList::Words(words)
    } else {
        ForList::Positional
    };

    // Skip to body
    skip_separators();

    // Parse body
    let body = parse_loop_body(is_foreach, false)?;

    Some(ZshCommand::For(ZshFor {
        var,
        list,
        body: Box::new(body),
        is_select: false,
    }))
}

/// Port of `par_case()` from `Src/parse.c:1209` — C decl `par_case(int *cmplx)`. AST variant: builds a `ZshCommand::Case` instead of emitting WC_CASE wordcode.
/// Parse case statement
/// Parse `case WORD in PATTERN) BODY ;; ... esac`. Direct port
/// of zsh/Src/parse.c:1209 `par_case`. Each case arm is a
/// (pattern_list, body, terminator) tuple where terminator is
/// `;;` (default), `;&` (fallthrough), or `;|` (continue testing).
fn par_case() -> Option<ZshCommand> {
    // C par_case (parse.c:1209-1241). Order of state toggles
    // matters — the lexer reads the case word in `incmdpos=0`
    // (so it's not promoted to a reswd), then the `in`/`{` in
    // `incmdpos=1, noaliases=1, nocorrect=1` (so the `in` literal
    // isn't alias-expanded or spell-corrected), then sets
    // `incasepat=1, incmdpos=0` before the first pattern.
    set_incmdpos(false);
    zshlex(); // skip 'case'

    let word = match tok() {
        STRING_LEX => {
            let w = tokstr().unwrap_or_default();
            // c:1222 — `incmdpos = 1;` before the next zshlex so the
            // `in` keyword is recognised. c:1223-1225 — save+force
            // noaliases / nocorrect.
            set_incmdpos(true);
            let ona = noaliases();
            let onc = nocorrect();
            set_noaliases(true);
            set_nocorrect(1);
            zshlex();
            // Restore noaliases/nocorrect after the `in`-or-`{` token
            // is in hand; both are unconditionally restored at c:1238-1239.
            let restore = |ona: bool, onc: i32| {
                set_noaliases(ona);
                set_nocorrect(onc);
            };
            (w, ona, onc, restore)
        }
        _ => {
            // c:1218-1219 — `if (tok != STRING) YYERRORV(oecused);`
            set_tok(LEXERR); // c:87 `tok = LEXERR`
            return None;
        }
    };
    let (word, ona, onc, restore) = word;

    skip_separators();

    // Expect 'in' or {
    let use_brace = tok() == INBRACE_TOK;
    if tok() == STRING_LEX {
        let s = tokstr();
        if s.map(|s| s != "in").unwrap_or(true) {
            // c:1228-1232 — restore noaliases/nocorrect on error path.
            restore(ona, onc);
            set_tok(LEXERR); // c:1232 YYERRORV(oecused)
            return None;
        }
    } else if !use_brace {
        restore(ona, onc);
        set_tok(LEXERR); // c:1232 YYERRORV(oecused)
        return None;
    }
    // c:1236-1239 — `incasepat = 1; incmdpos = 0; noaliases = ona;
    // nocorrect = onc;` — set the case-pattern context AND restore
    // alias/correct state BEFORE the zshlex that consumes `in`/`{`.
    set_incasepat(1);
    set_incmdpos(false);
    restore(ona, onc);
    zshlex();

    let mut arms = Vec::new();

    loop {
        // No arm-count cap: zsh `case` statements have no limit, and compsys
        // dispatchers (`_describe`, `_git`, generated `_arguments` bodies) emit
        // huge case bodies. The loop terminates on `esac` / EOF below; a former
        // 10_000-arm cap silently truncated (and errored on) larger ones.

        // Set incasepat BEFORE skipping separators so lexer knows we're in case pattern context
        // This affects how [ and | are lexed
        set_incasepat(1);

        skip_separators();

        // Check for end
        // Note: 'esac' might be String "esac" if incasepat > 0 prevents reserved word recognition
        let is_esac = tok() == ESAC
            || (tok() == STRING_LEX && tokstr().map(|s| s == "esac").unwrap_or(false));
        if (use_brace && tok() == OUTBRACE_TOK) || (!use_brace && is_esac) {
            // c:1395-1397 — `incmdpos = 1; incasepat = 0; zshlex();`: the word
            // after `esac` is in command position, so a closing `fi` / `done`
            // / `}` right after it is still a reserved word. Without it
            // `if true; then case a in a) print x;; esac fi` was a parse error.
            set_incmdpos(true);
            set_incasepat(0);
            zshlex();
            break;
        }

        // Also break on EOF. c:Src/parse.c:1209 par_case requires
        // ESAC (or `}` in brace form) to close the block — reaching
        // ENDINPUT without either is a parse error (`case ... esack`
        // typo absorbs `esack` as part of the body and silently
        // terminates rc=0 otherwise). Bug #400.
        // c:1256-1257 — `if (tok != STRING) YYERRORV(oecused);`: the
        // diagnostic is par_event's "parse error near `<zshlextext>'", which
        // names the last token read (`case x in a) echo;;` → near `;;').
        if tok() == ENDINPUT || tok() == LEXERR {
            set_incasepat(0);
            set_tok(LEXERR); // c:87 `tok = LEXERR`
            return None;
        }

        // c:1250 — `if (tok == INPAR) zshlex();` — leading-paren
        // skip path. Used when the lexer DID return INPAR_TOK (e.g.
        // SHGLOB or incmdpos forced it). In the normal case-pattern
        // path the lexer absorbs `(...)` into one Stringg and the
        // hack at c:1322 strips the surrounding parens later. Both
        // paths land here.
        let leading_inpar_consumed = tok() == INPAR_TOK;
        if leading_inpar_consumed {
            zshlex();
        }

        // c:1255-1262 — read pattern STRING. zsh's parser falls
        // straight into the STRING reader after the optional INPAR.
        // BAR before any pattern means empty string.
        let mut patterns = Vec::new();
        // Tracks whether the c:1322-1354 hack has fired (paren-
        // wrapped Stringg absorbed by the lexer). When it has, the
        // closing `)` was already absorbed — no separate OUTPAR
        // arm-close to consume.
        let mut absorbed_outpar = false;

        // Nested-paren pattern: the user wrote `((alt|alt)tail)` —
        // the leading arm-INPAR was consumed; the NEXT token is also
        // INPAR. zinit.zsh:2946 hits this with `((add-|)fpath)`
        // meaning "fpath or add-fpath".
        //
        // The current lexer (cmd_or_math rewind path interacting
        // with gettokstr) drops ONE of the two `)` chars on the
        // way out, so the token stream is INPAR INPAR STRING BAR
        // STRING OUTPAR — only ONE OUTPAR for two source `)`. We
        // can't reconstruct the exact pattern from these tokens.
        // Proper fix needs to land in lex.rs (cmd_or_math rewind +
        // gettokstr LX2_INPAR/OUTPAR interplay) — see docs/BUGS.md
        // entry "case-pattern nested-paren lexer gap".
        //
        // Workaround: consume every token up to and INCLUDING the
        // arm-closing OUTPAR, build a best-effort pattern string,
        // set `absorbed_outpar = true` so the post-pattern OUTPAR
        // check below skips. The resulting glob may match a slightly
        // wider set than the original (`(add-|fpath)` vs
        // `(add-|)fpath`) but the rest of the script parses + runs.
        // Unblocking sourcing zinit-style configs is the priority.
        if leading_inpar_consumed && tok() == INPAR_TOK {
            let mut buf = String::new();
            let mut depth = 0i32;
            loop {
                match tok() {
                    INPAR_TOK => {
                        buf.push('(');
                        depth += 1;
                        zshlex();
                    }
                    OUTPAR_TOK => {
                        // The single OUTPAR token in the stream is
                        // simultaneously the inner glob-group close
                        // AND the arm close (lexer collapses both).
                        // Consume it, balance the inner depth, exit.
                        // `absorbed_outpar = true` tells the shared
                        // post-pattern check below to skip its own
                        // consume.
                        if depth > 0 {
                            buf.push(')');
                            depth -= 1;
                        }
                        zshlex();
                        break;
                    }
                    STRING_LEX => {
                        if let Some(s) = tokstr() {
                            if s == "esac" {
                                break;
                            }
                            buf.push_str(&s);
                        }
                        set_incasepat(2);
                        zshlex();
                    }
                    BAR_TOK => {
                        buf.push('|');
                        set_incasepat(1);
                        zshlex();
                    }
                    _ => break,
                }
            }
            patterns.push(buf);
            set_incasepat(0);
            set_incmdpos(true);
            absorbed_outpar = true;
        }

        // Skip the legacy STRING/BAR pattern-read loop when the
        // nested-paren branch above already populated `patterns` and
        // consumed the arm-close. Otherwise the legacy loop would
        // greedily absorb the body's first command token (`echo`) as
        // another alt-pattern.
        if !patterns.is_empty() && absorbed_outpar {
            // skip to body parse
        } else {
            // c:1253-1256 — `if (tok == BAR) { str = dupstring("");
            // skip_zshlex = 1; }` — an arm that OPENS with `|` has the
            // empty string as its first alternative (`case '' in |burble)`).
            if tok() == BAR_TOK {
                patterns.push(String::new());
            }
            loop {
                if tok() == STRING_LEX {
                    let s = tokstr();
                    if s.as_deref().map(|s| s == "esac").unwrap_or(false) {
                        break;
                    }
                    let mut str_val = s.unwrap_or_default();

                    // c:1322-1354 hack: when this is the first alt AND
                    // the string starts with the Inpar marker, the lexer
                    // absorbed the whole `(...)` as one token. Chuck the
                    // blanks around `|`/parens at depth 1 (c:1332-1338 —
                    // `( d | e )` must become `(d|e)`), then strip the
                    // surrounding parens — the remainder IS the pattern.
                    // The closing arm-paren was absorbed too, so we don't
                    // expect a separate OUTPAR token afterward.
                    if patterns.is_empty() && str_val.starts_with(crate::ported::zsh_h::Inpar) {
                        use crate::ported::zsh_h::{Bar, Inpar, Outpar};
                        let meta = crate::ported::zsh_h::Meta as char;
                        let blank =
                            |c: char| c.is_ascii() && crate::ported::ztype_h::iblank(c as u8);
                        let mut chars: Vec<char> = str_val.chars().collect();
                        let mut pct = 0i32;
                        let mut i = 0usize;
                        let mut end_idx: Option<usize> = None;
                        while i < chars.len() {
                            if chars[i] == Inpar {
                                pct += 1;
                            }
                            if pct == 1 {
                                // c:1332-1334 — chuck blanks AFTER `|`/`(`.
                                if chars[i] == Bar || chars[i] == Inpar {
                                    while i + 1 < chars.len() && blank(chars[i + 1]) {
                                        chars.remove(i + 1);
                                    }
                                }
                                // c:1335-1338 — chuck blanks BEFORE `|`/`)`
                                // (not Meta-escaped blanks).
                                if chars[i] == Bar || chars[i] == Outpar {
                                    while i >= 1
                                        && blank(chars[i - 1])
                                        && (i < 2 || chars[i - 2] != meta)
                                    {
                                        chars.remove(i - 1);
                                        i -= 1;
                                    }
                                }
                            }
                            if chars[i] == Outpar {
                                pct -= 1;
                                if pct == 0 {
                                    end_idx = Some(i);
                                    break;
                                }
                            }
                            i += 1;
                        }
                        if let Some(idx) = end_idx {
                            // c:1346-1352 — the surrounding-paren strip is only
                            // valid when the WHOLE string is `(...)` (close-paren
                            // is the last char). C asserts this with
                            // `DPUTS(*str != Inpar || str[sl-1] != Outpar)` and
                            // `YYERRORV` on `if (*s || pct ...)` when anything
                            // follows the matched close-paren. When trailing
                            // content exists (`(a|b)*`, `(a|b)c`), the `(...)` is
                            // a glob GROUP, not the optional case-opener — keep
                            // the whole string verbatim as one pattern and let
                            // the separate arm-closing `)` (OUTPAR_TOK) be
                            // consumed below. Stripping here turned `(a|b)*` into
                            // `a|b*` ("a" or "b*"), breaking OS-dispatch case arms.
                            if idx == chars.len() - 1 {
                                chars.remove(idx);
                                chars.remove(0);
                                str_val = chars.into_iter().collect();
                                absorbed_outpar = true;
                            }
                        }
                    }
                    patterns.push(str_val);
                    if absorbed_outpar {
                        // c:Src/parse.c:1300-1302 — after a whole-`(...)`
                        // pattern the next token may be the body's first
                        // command word; C lexes it with `incasepat = -1;
                        // incmdpos = 1;` so assignments (`out+=hit`)
                        // become ENVSTRING instead of a plain STRING
                        // (lex.c:1229-1230 gates ENVSTRING on incmdpos).
                        set_incasepat(-1);
                        set_incmdpos(true);
                    } else {
                        set_incasepat(2);
                    }
                    zshlex();
                    // When the hack fired the closing `)` is already
                    // consumed; don't read alt-`|` continuations either.
                    if absorbed_outpar {
                        break;
                    }
                } else if tok() != BAR_TOK {
                    break;
                }

                if tok() == BAR_TOK {
                    set_incasepat(1);
                    zshlex();
                    // c:1360-1367 — after consuming a `|`, C re-lexes and
                    // switches on the token:
                    //     case OUTPAR: case BAR: /* Empty string */
                    //         str = dupstring(""); break;
                    // so `spurble|)`, `a||b` and `durgle|)` all carry an
                    // empty alternative. The old loop silently dropped it.
                    if tok() == BAR_TOK || tok() == OUTPAR_TOK {
                        patterns.push(String::new());
                    }
                } else {
                    break;
                }
            }
        } // end else of "skip legacy loop when nested-paren branch fired"
        set_incasepat(0);

        // c:1305 — expect OUTPAR (arm-close) when the hack didn't
        // already swallow it.
        //
        // Bug #34 in docs/BUGS.md: the absorbed-pattern hack assumed
        // the leading `(` and the case-arm closing `)` were both
        // absorbed into the single STRING token. That's true for
        // `(x))` (the inner `)` closes the absorbed group; the second
        // `)` is the arm closer) only when the lexer slurps BOTH.
        // The Rust lexer slurps just `(x|y)` (one balanced pair); the
        // second `)` arrives as a separate OUTPAR_TOK that must still
        // be consumed as the case-arm closer. Detect and consume it.
        if !absorbed_outpar {
            if tok() != OUTPAR_TOK {
                // c:1356 — neither `)` nor `|` after the pattern:
                // `YYERRORV(oecused);`.
                set_tok(LEXERR); // c:87 `tok = LEXERR`
                return None;
            }
            // c:Src/parse.c:1257-1258 — `if (tok != STRING)
            // YYERRORV(oecused);` C requires at least one pattern
            // STRING before `)`. zshrs accepted empty `case x in)`
            // and silently fell through to the next iteration with
            // an empty pattern arm, swallowing the rest of the
            // script. Reject the empty-pattern shape unless a
            // leading INPAR was consumed (the `(pat)` form has
            // already validated the pattern inside). Bug #161 in
            // docs/BUGS.md.
            if patterns.is_empty() && !leading_inpar_consumed {
                set_tok(LEXERR); // c:1257 YYERRORV(oecused)
                return None;
            }
            set_incmdpos(true);
            zshlex();
            // When the lexer emitted a separate INPAR_TOK at the
            // arm start (consumed via `leading_inpar_consumed`
            // above), the OUTPAR_TOK we just consumed closed the
            // alternation GROUP. If the next token is ALSO
            // OUTPAR_TOK, the user wrote `(pat))` and that second
            // `)` is the case-arm closer that still needs to be
            // consumed before body parsing. Bug #34 in
            // docs/BUGS.md.
            if leading_inpar_consumed && tok() == OUTPAR_TOK {
                zshlex();
            }
        } else if tok() == OUTPAR_TOK {
            // The lexer absorbed `(pat)` as the pattern but left the
            // case-arm closing `)` as a separate OUTPAR_TOK. Consume
            // it now so body parsing starts at the body, not at `)`.
            set_incmdpos(true);
            zshlex();
        } else {
            set_incmdpos(true);
        }

        // Parse body. Pass end_tokens explicitly so the body's
        // parser stops at DSEMI/SEMIAMP/SEMIBAR/ESAC without
        // tripping parse_program_until's orphan-terminator check
        // (line 7131) which only fires when end_tokens is None.
        // Without this, a case arm whose body has no trailing
        // `;;` before `esac` (last arm — zsh accepts the dangling
        // form) produced "parse error near orphan terminator" on
        // the closing `esac`. zsh's par_case at parse.c:1318 sets
        // up the case-arm reader to recognize the same terminator
        // set; the Rust port was passing the implicit-None and
        // hitting the top-level orphan check.
        let body = parse_program_until(Some(&[DSEMI, SEMIAMP, SEMIBAR, ESAC]), false);

        // Get terminator. Set incasepat=1 BEFORE the zshlex
        // advance so the next token (the next arm's pattern, like
        // `[a-z]`) gets tokenized in pattern context. Without
        // this, a `[`-prefixed pattern after the FIRST arm became
        // Inbrack instead of String and the pattern-loop bailed
        // out with "expected ')' in case pattern".
        // c:Src/parse.c:1391 — `incasepat = 1; incmdpos = 0;` BEFORE
        // the zshlex that advances past `;;` to the next arm's first
        // token. The incmdpos=0 setting is what makes the lexer
        // absorb the next arm's `((add-|)fpath)` into a single STRING
        // (gettokstr's LX2_INPAR path at lex.c:1080+ runs only when
        // incmdpos is FALSE — at incmdpos=1 the lexer emits raw
        // INPAR_TOK for the inner `(` and par_case's pattern-read
        // loop has no path to recover). Our Rust port previously set
        // only incasepat=1 and not incmdpos=0, which forced
        // multi-arm patterns like `((add-|)fpath)` to fail with
        // "expected ')' in case pattern" — surfaced on
        // zinit.zsh:2946.
        let terminator = match tok() {
            DSEMI => {
                set_incasepat(1);
                set_incmdpos(false);
                zshlex();
                CaseTerm::Break
            }
            SEMIAMP => {
                set_incasepat(1);
                set_incmdpos(false);
                zshlex();
                CaseTerm::Continue
            }
            SEMIBAR => {
                set_incasepat(1);
                set_incmdpos(false);
                zshlex();
                CaseTerm::TestNext
            }
            // c:1386-1387 — `if ((tok == ESAC && !brflag) || (tok ==
            // OUTBRACE && brflag)) break;` — left for the loop top, which
            // consumes the closer.
            ESAC if !use_brace => CaseTerm::Break,
            STRING_LEX if !use_brace && tokstr().as_deref() == Some("esac") => CaseTerm::Break,
            OUTBRACE_TOK if use_brace => CaseTerm::Break,
            // c:1388-1389 — `if (tok != DSEMI && tok != SEMIAMP && tok !=
            // SEMIBAR) YYERRORV(oecused);`
            _ => {
                set_incasepat(0);
                set_tok(LEXERR); // c:87 `tok = LEXERR`
                return None;
            }
        };

        if !patterns.is_empty() {
            arms.push(CaseArm {
                patterns,
                body,
                terminator,
            });
        }
    }

    Some(ZshCommand::Case(ZshCase { word, arms }))
}

/// Port of `par_if()` from `Src/parse.c:1411` — C decl `par_if(int *cmplx)`. AST variant: builds a `ZshIf` instead of emitting WC_IF wordcode.
/// Parse if statement
/// Parse `if COND; then BODY; [elif COND; then BODY;]* [else BODY;] fi`, plus
/// the brace forms `if COND { BODY } [elif COND { BODY }]* [else { BODY }]`.
///
/// Faithful port of zsh/Src/parse.c:1411 `par_if` — a SINGLE `for(;;)` loop that
/// processes the `if` arm and every `elif` arm through the same body code, so the
/// C's one `if (tok == SEPER) break;` after a brace body (c:1471-1472) covers
/// if- and elif-bodies uniformly. (The previous port split this into a pre-loop
/// if-body + a separate elif/else loop, which forced that single break to be
/// duplicated per arm and needed a special `fi`-gate; the single loop retires
/// all of that.) The C emits WC_IF wordcodes per arm; zshrs builds a ZshIf AST —
/// arm 0 -> (cond, then), later arms -> elif, plus an optional else_.
fn par_if() -> Option<ZshCommand> {
    // tok() == IF on entry (the dispatcher matched `if`); the loop consumes it.
    let mut if_cond: Option<Box<ZshProgram>> = None;
    let mut if_then: Option<Box<ZshProgram>> = None;
    let mut elif: Vec<(ZshProgram, ZshProgram)> = Vec::new();
    let mut else_: Option<Box<ZshProgram>> = None;
    // `usebrace` mirrors c:1449/1458 — the body form of the LAST arm parsed; it
    // gates whether a trailing `else {` is a brace-else (c:1492 `tok == INBRACE
    // && usebrace`) or, for a then-form arm, a brace-group statement inside the
    // else body that still ends at `fi` (p10k.zsh:5575).
    let mut usebrace = false;
    // Mirrors C's `xtok` where the loop exits, for the post-loop else check
    // (c:1487 `if (xtok == ELSE || tok == ELSE)`).
    let mut xtok_at_exit = IF;
    // c:1476-1482 — set when the SHORTLOOPS arm took the body; C `break`s
    // straight out of the arm loop there, so no `fi`/`else` may follow.
    let mut short_form = false;

    loop {
        let xtok = tok(); // c:1420
                          // c:1422-1425 — `fi` at the top closes a then-form if/elif chain.
        if xtok == FI {
            set_incmdpos(false);
            zshlex();
            xtok_at_exit = FI;
            break;
        }
        zshlex(); // c:1426 — consume IF / ELIF / ELSE
                  // c:1428-1429 — `else` ends the arm loop (handled after it).
        if xtok == ELSE {
            xtok_at_exit = ELSE;
            break;
        }
        skip_separators(); // c:1430
                           // c:1432-1435 — only IF / ELIF may open an arm.
        if xtok != IF && xtok != ELIF {
            set_tok(LEXERR); // c:1434 YYERRORV(oecused)
            return None;
        }
        // c:1438 — the cond is an ordinary list; a `{ … }` body opener ends it
        // via the no-separator chaining rule, so only THEN is a hard stop.
        // fast-syntax-highlighting.plugin.zsh:365-375:
        //   if [[ … ]] { … } elif { type curl … } { … }
        // COND_LIST_DEPTH: suppress the Rust-only post-compound STRING guard
        // (see the thread_local's comment) for the condition list — a word
        // straight after `{ … }` here is the SHORTLOOPS body, not an error.
        COND_LIST_DEPTH.with(|d| d.set(d.get() + 1));
        let cond = parse_program_until(Some(&[THEN]), false);
        COND_LIST_DEPTH.with(|d| d.set(d.get() - 1));
        set_incmdpos(true); // c:1438
                            // c:1440-1443 — `if (tok == ENDINPUT) { cmdpop();
                            // YYERRORV(oecused); }`. YYERRORV only sets LEXERR; the message
                            // ("parse error near `if'") comes from par_list's yyerror, so don't
                            // invent one here — `eval "if"` must print zsh's wording
                            // (A01grammar.ztst:505).
        if tok() == ENDINPUT {
            set_tok(LEXERR); // c:87 `tok = LEXERR`
            return None;
        }
        skip_separators(); // c:1444
        xtok_at_exit = FI; // c:1446 — `xtok = FI` sentinel for the else check

        let mut this_arm_brace = false;
        let body = if tok() == THEN {
            // c:1448-1456 — classic `then … (fi|elif|else)`.
            zshlex(); // consume then
            let b = parse_program_until(Some(&[ELSE, ELIF, FI]), false);
            set_incmdpos(true);
            b
        } else if tok() == INBRACE_TOK {
            // c:1457-1473 — brace body `{ … }`.
            this_arm_brace = true;
            zshlex(); // consume {
            let b = parse_program_until(Some(&[OUTBRACE_TOK]), false);
            if tok() != OUTBRACE_TOK {
                set_tok(LEXERR); // c:87 YYERRORV(oecused) — no own message
                return None;
            }
            zshlex(); // c:1469 — consume }
            set_incmdpos(true); // c:1470
            b
        } else if unset(SHORTLOOPS) {
            // c:1473-1475 — `else if (unset(SHORTLOOPS)) { cmdpop();
            // YYERRORV(oecused); }`. YYERRORV only flags LEXERR; the single
            // diagnostic ("parse error near `<zshlextext>'") comes from
            // par_list's yyerror. zshrs used to invent its own wording, so
            // `if true;\n:\nfi` said "expected `then' or `{' after if
            // condition" where zsh says "parse error near `fi'"
            // (A01grammar.ztst:241).
            set_tok(LEXERR); // c:87 `tok = LEXERR`
            return None;
        } else {
            // c:1476-1482 — SHORTLOOPS short form:
            //     cmdpop(); cmdpush(nc); par_save_list1(cmplx);
            //     ecbuf[pp] = WCB_IF(type, …); incmdpos = 1; break;
            // One sublist is the whole body and the `if` ENDS here — no
            // `fi`, no `else`. `if { true } print true`
            // (A01grammar.ztst:500) needs this; without the arm the parse
            // died on the body's first word.
            short_form = true;
            par_list1().map(|sublist| ZshProgram {
                lists: vec![ZshList {
                    sublist,
                    flags: ListFlags::default(),
                }],
            })?
        };
        usebrace = this_arm_brace;

        // Record the arm: the first is the `if`, the rest are `elif`.
        if if_cond.is_none() {
            if_cond = Some(Box::new(cond));
            if_then = Some(Box::new(body));
        } else {
            elif.push((cond, body));
        }

        // c:1471-1472 — after a brace body, a following separator ends the
        // construct; break WITHOUT consuming it so the outer par_list keeps the
        // separator between the if and the next command (otherwise that command
        // becomes a "STRING after compound" parse error). A then-form body
        // instead falls through to the loop top to read the next ELSE/ELIF/FI;
        // a brace body with no separator also falls through (e.g. `} elif`,
        // `} else` on the same line). Because a brace arm never reaches the
        // loop-top `fi`-consume, it cannot steal an enclosing then-form's `fi`.
        // ENDINPUT is NOT a separator: C breaks only on `tok == SEPER`, so
        // `if [[ x ]] { y }` at end of input loops back and YYERRORs
        // ("parse error near `}'"), exactly as zsh does.
        if this_arm_brace && matches!(tok(), SEPER | NEWLIN | SEMI) {
            break;
        }
        // c:1481 — the SHORTLOOPS arm ends with `break;` (with xtok still FI
        // from c:1445), so the construct is complete: no `fi`, no `else`.
        if short_form {
            break;
        }
    }

    // c:1487-1505 — the optional else clause. When the loop exited via
    // `xtok == ELSE`, the `else` keyword was already consumed by the loop's
    // zshlex; the inner guard re-consumes only if we are somehow still on it.
    if xtok_at_exit == ELSE || tok() == ELSE {
        if tok() == ELSE {
            zshlex();
        }
        skip_separators(); // c:1490
        let ebody = if usebrace && tok() == INBRACE_TOK {
            // c:1492-1497 — brace else (only when the preceding arm was brace).
            zshlex(); // consume {
            let b = parse_program_until(Some(&[OUTBRACE_TOK]), false);
            if tok() != OUTBRACE_TOK {
                set_tok(LEXERR); // c:87 YYERRORV(oecused) — no own message
                return None;
            }
            zshlex(); // consume }
            b
        } else {
            // c:1498-1502 — then-form else, stops at and consumes `fi`.
            let b = parse_program_until(Some(&[FI]), false);
            if tok() != FI {
                set_tok(LEXERR); // c:1503 YYERRORV(oecused)
                return None;
            }
            zshlex(); // consume fi
            b
        };
        set_incmdpos(false); // c:1502 — incmdpos = 0 after the else body
        else_ = Some(Box::new(ebody));
    }

    let cond = match if_cond {
        Some(c) => c,
        None => {
            set_tok(LEXERR); // c:87 YYERRORV(oecused)
            return None;
        }
    };
    let then = if_then.expect("if_then set with if_cond");
    Some(ZshCommand::If(ZshIf {
        cond,
        then,
        elif,
        else_,
    }))
}

/// Port of `par_while()` from `Src/parse.c:1521` — C decl `par_while(int *cmplx)`. AST variant; the `until` flag selects C's `tok == UNTIL` branch (c:1524).
/// Parse while/until loop
/// Parse `while COND; do BODY; done` and `until COND; do BODY; done`.
/// Direct port of zsh/Src/parse.c:1521 `par_while`. The
/// `until` variant is the same loop with the condition negated.
fn par_while(until: bool) -> Option<ZshCommand> {
    zshlex(); // skip while/until

    // c:1521-1551 par_while — the condition's parser must stop at
    // `do` or `{`. Without an explicit end-token set, parse_program
    // consumes the brace-form body as additional condition lists,
    // leaving parse_loop_body with nothing — `while (( i++ < 3 )) {
    // echo $i }` silently parsed but executed nothing.
    // c:1528 — `par_save_list(cmplx);` — the cond is an ORDINARY
    // list: a leading `{...}` block is the cond's first command
    // (`while {false} {body}`), and the body INBRACE is reachable
    // because a list followed by `{` without a separator ends (the
    // chaining rule in parse_program_until). DOLOOP stays in the
    // stop set because `do` at command position can't start a
    // command. INBRACE_TOK was previously (wrongly) in the set too,
    // which made a brace-form COND parse as an empty cond + body.
    // COND_LIST_DEPTH: as for par_if's condition — a word straight after a
    // compound cond (`while (( i-- > 0 )) print $i`) is the SHORTLOOPS body
    // (c:1548-1549 `par_save_list1`), not a stray word after a compound.
    COND_LIST_DEPTH.with(|d| d.set(d.get() + 1));
    let cond = Box::new(parse_program_until(Some(&[DOLOOP]), false));
    COND_LIST_DEPTH.with(|d| d.set(d.get() - 1));

    skip_separators();
    let body = parse_loop_body(false, false)?;

    // c:Src/parse.c:1521-1551 par_while — WC_WHILE wordcode is tagged
    // with WC_WHILE_TYPE differentiating WHILE vs UNTIL at the wordcode
    // layer. The AST mirror in zsh_ast.rs has separate Until(ZshWhile)
    // and While(ZshWhile) variants; route by the `until` flag here so
    // downstream pattern-matchers can distinguish without poking
    // inside the payload's bool.
    let w = ZshWhile {
        cond,
        body: Box::new(body),
        until,
    };
    Some(if until {
        ZshCommand::Until(w) // c:1521 (WC_WHILE_TYPE = WC_WHILE_UNTIL)
    } else {
        ZshCommand::While(w) // c:1521 (WC_WHILE_TYPE = WC_WHILE_WHILE)
    })
}

/// Port of `par_repeat()` from `Src/parse.c:1565` — C decl `par_repeat(int *cmplx)`. AST variant.
/// Parse repeat loop
/// Parse `repeat N; do BODY; done`. Direct port of
/// zsh/Src/parse.c:1565 `par_repeat`. The C source supports
/// the SHORTLOOPS short-form `repeat N CMD` (no do/done) — zshrs's
/// parser doesn't yet special-case that variant.
fn par_repeat() -> Option<ZshCommand> {
    // c:1572 — `incmdpos = 0;` BEFORE lexing the count word, so
    // checkalias's `(incmdpos && tok == STRING)` gate stays closed and
    // the count is NEVER alias-expanded. OMZL::directories.zsh defines
    // `alias 1='cd -1'`; without this, `repeat 1; do …; done` (hsmw
    // file:114) expanded `1` mid-header and errored "parse error near
    // `do'" (#665, sibling of the funcdef-name bug #662).
    set_incmdpos(false);
    zshlex(); // skip 'repeat'

    let count = match tok() {
        STRING_LEX => {
            let c = tokstr().unwrap_or_default();
            // c:1577-1578 — `incmdpos = 1; zshlex();` — restore command
            // position before the separator/`do` lex so the body's
            // reserved words promote again.
            set_incmdpos(true);
            zshlex();
            c
        }
        _ => {
            set_tok(LEXERR); // c:1575 YYERRORV(oecused)
            return None;
        }
    };

    skip_separators();
    // c:1600 — par_repeat's short-form gate is wider: it unlocks
    // when SHORTLOOPS OR SHORTREPEAT is set (vs SHORTLOOPS alone for
    // for/while). Pass `is_repeat=true` so parse_loop_body
    // applies that widened gate.
    let body = parse_loop_body(false, true)?;

    Some(ZshCommand::Repeat(ZshRepeat {
        count,
        body: Box::new(body),
    }))
}

/// Port of `par_subsh()` from `Src/parse.c:1619` — C decl `par_subsh(int *cmplx, int zsh_construct)`. AST variant, `(...)` arm only.
/// Parse (...) subshell
/// Parse a subshell `( ... )`. Direct port of zsh/Src/parse.c:1619
/// `par_subsh`. Body parses as a normal list; the subshell wrapper
/// fork-isolates execution in the executor.
fn par_subsh(zsh_construct: bool) -> Option<ZshCommand> {
    zshlex(); // skip (
              // c:Src/parse.c:par_subsh — `parse_event(OUTPAR)` parses until
              // the matching `)`. zshrs's previous port called bare
              // `parse_program()` (parse_program_until(None, false)) which has no
              // way to know it should stop at OUTPAR_TOK — at top-level
              // that's fine (the outer loop just sees an extra OUTPAR after
              // the inner body), but the parse_event-equivalent's new
              // yyerror-on-unconsumed-token behavior at parse_program_until's
              // None arm now reports a spurious "parse error near `)'" when
              // the construct ends. Pass OUTPAR_TOK so parse_program_until
              // stops cleanly at the closing paren.
    let prog = parse_program_until(Some(&[OUTPAR_TOK]), false);
    // c:1630-1631 — `if (tok != ((otok == INPAR) ? OUTPAR : OUTBRACE))
    // YYERRORV(oecused);`. This arm is only reached from par_cmd's
    // INPAR_TOK case (c:1010-1014), so the expected closer is OUTPAR.
    // Silently accepting a missing `)` let an unterminated subshell parse
    // clean: `zsh -fc '('` is a parse error with status 1, while zshrs
    // returned 0 and ran nothing. `((` inherits the same path (the lexer
    // emits two INPARs), which is why `((1` reached the command layer and
    // reported `command not found: 1` instead of a parse error.
    if tok() != OUTPAR_TOK {
        set_tok(LEXERR); // c:1631 YYERRORV(oecused)
        return None;
    }
    set_incmdpos(!zsh_construct); // c:1632
    zshlex(); // c:1633
    Some(ZshCommand::Subsh(Box::new(prog)))
}

/// Port of `par_funcdef()` from `Src/parse.c:1672` — C decl `par_funcdef(int *cmplx)`. AST variant.
/// Parse function definition
/// Parse `function NAME { BODY }` or `NAME () { BODY }`. Direct
/// port of zsh/Src/parse.c:1672 `par_funcdef`. zsh handles
/// the multiple keyword shapes (function FOO, FOO (), function FOO ()),
/// the optional `[fname1 fname2 ...]` for multi-name function defs,
/// and the `function FOO () { ... }` traditional/POSIX hybrid form.
fn par_funcdef() -> Option<ZshCommand> {
    // c:1680-1681 — `nocorrect = 1; incmdpos = 0;` BEFORE lexing the
    // name. incmdpos=0 keeps checkalias's `(incmdpos && tok == STRING)`
    // gate closed, so the word after `function` is NEVER alias-expanded
    // (`alias ts='cd x'; function ts { }` must define `ts`, not `cd`).
    // nocorrect=1 likewise suppresses spell-correction on the name.
    set_nocorrect(1);
    set_incmdpos(false);
    zshlex(); // skip 'function'

    let mut names = Vec::new();
    let mut tracing = false;

    // Handle options like -T and function names. Two subtleties:
    //
    //   1. Flags: zsh's lexer encodes a leading `-` as
    //      `zsh_h::Dash` (`\u{e19b}`, `Src/zsh.h:182`) inside the String tokstr.
    //      The previous `s.starts_with('-')` check failed for
    //      `\u{e19b}T`, so `function -T NAME { body }` slipped the
    //      `-T` token into `names` and the function got registered
    //      as `T` plus the intended `NAME`.
    //
    //   2. Body opener: zsh's lexer emits the opening `{` as a
    //      String (not INBRACE_TOK) when it follows the String
    //      NAME — the preceding name token resets incmdpos to
    //      false, and only `{` immediately followed by `}` (the
    //      empty-body case) gets promoted to Inbrace. The funcdef
    //      parser must recognise the bare-`{` String as the body
    //      opener; otherwise `function NAME { body }` falls through
    //      to `_ => break`, no body parses, and the FuncDef never
    //      lands in the AST. This is consistent with C zsh's
    //      par_funcdef which knows it's in funcdef-header context
    //      and accepts the brace either way.
    // c:Src/parse.c:1687-1698 —
    //   /* Consume an initial (-T), (--), or (-T --).
    //    * Anything else is a literal function name.
    //    */
    //   if (tok == STRING && tokstr[0] == Dash) {
    //       if (tokstr[1] == 'T' && !tokstr[2]) { ++do_tracing; zshlex(); }
    //       if (tok == STRING && tokstr[0] == Dash &&
    //           tokstr[1] == Dash && !tokstr[2]) { zshlex(); }
    //   }
    // The option prologue runs EXACTLY ONCE, before the name wordlist, and
    // `--` ends it: `function -- -T { … }` defines a function literally
    // named `-T`, and `function -- { … }` is a plain anonymous function.
    // The old code tested for `-T` inside the name loop instead, so `--`
    // was taken as a NAME and a post-`--` `-T` was eaten as the option.
    {
        let lead: Option<Vec<char>> = if tok() == STRING_LEX {
            tokstr().map(|t| t.chars().collect())
        } else {
            None
        };
        let is_dash = |c: char| c == '-' || c == Dash;
        if let Some(sc) = lead {
            if sc.first().copied().is_some_and(is_dash) {
                // c:1689-1692 — the `-T` tracing option.
                if sc.len() == 2 && sc[1] == 'T' {
                    tracing = true;
                    zshlex();
                }
                // c:1693-1697 — an immediately-following `--` ends options.
                let after: Option<Vec<char>> = if tok() == STRING_LEX {
                    tokstr().map(|t| t.chars().collect())
                } else {
                    None
                };
                if let Some(a) = after {
                    if a.len() == 2 && is_dash(a[0]) && is_dash(a[1]) {
                        zshlex();
                    }
                }
            }
        }
    }

    loop {
        match tok() {
            STRING_LEX => {
                let _ts_s = tokstr()?;
                let s = _ts_s.as_str();
                // c:1702 — `if ((*tokstr == Inbrace || *tokstr == '{') && !tokstr[1])`.
                // Body opener can be either the literal `{` (early-return
                // path at lex.c:1141-1144 / lex.rs LX2_INBRACE cmdpos
                // branch) or the Inbrace marker `\u{e18f}` (lex.c:1420
                // post-switch add(c) where c was rewritten via lextok2).
                if s == "{" || s == "\u{e18f}" {
                    break;
                }
                // c:Src/parse.c par_funcdef — `if (tokstr[0] == Dash &&
                // tokstr[1] == 'T' && !tokstr[2])`: ONLY the exact word
                // `-T` (Dash + 'T' + nothing else) is the tracing option.
                // Every other word — INCLUDING names that merely start
                // with `-` or `+` such as `-zui_std_button_ext` or `+foo`
                // — is a function NAME. The previous check skipped any
                // `-`/`+`-prefixed word as an option, so all 47 of ZUI's
                // `function -zui_std_*()` names were dropped, leaving an
                // anonymous `function { body }` that executed its body at
                // parse time (the cascade of "command not found: -zui_std_*"
                // and "bad substitution" while sourcing stdlib.lzui).
                // c:1700-1706 — past the option prologue above, EVERY
                // remaining STRING is a literal function name (including
                // `-T`, `--`, `-zui_std_*`, `+foo`, …).
                names.push(s.to_string());
                zshlex();
            }
            INBRACE_TOK | INOUTPAR | SEPER | NEWLIN => break,
            _ => break,
        }
    }

    // c:1715-1716 — `nocorrect = 0; incmdpos = 1;` after the name
    // wordlist, BEFORE lexing past `()`/separators into the body, so
    // body keywords (`if`, `while`, …) get reserved-word promotion
    // again (the header ran with incmdpos=0 to keep names alias-free).
    set_nocorrect(0);
    set_incmdpos(true);

    // Optional ()
    let saw_paren = tok() == INOUTPAR;
    // Track the byte position just past `()` / the most-recent separator, so an
    // UNBRACED short body (`function f () cmd`) can be sliced for `functions`
    // rendering. pos() AFTER a zshlex is already past the next token (one-token
    // lookahead), so record it BEFORE each advance (mirrors parse.rs:2484).
    let mut body_mark = crate::funcdef_capture::body_mark_begin();
    if saw_paren {
        zshlex();
    }

    while tok() == SEPER || tok() == NEWLIN {
        crate::funcdef_capture::body_mark_restart(&mut body_mark);
        zshlex();
    }

    // Body opener: real Inbrace OR a String containing the literal `{`
    // (early-return path) OR a String containing the Inbrace marker
    // `\u{e18f}` (bct++ path post-switch add). C parse.c:1702 handles
    // both string forms via `*tokstr == Inbrace || *tokstr == '{'`.
    let body_opener_is_string_brace =
        tok() == STRING_LEX && tokstr().map(|s| s == "{" || s == "\u{e18f}").unwrap_or(false);
    if tok() == INBRACE_TOK || body_opener_is_string_brace {
        // Capture body_start BEFORE the lexer advances past the
        // first body token. After the previous zshlex consumed
        // `{`, lexer.pos points just past `{` (which is where the
        // body source starts). The next `zshlex()` would advance
        // past the first token (`echo`), making body_start land
        // mid-body and lose the first word — `typeset -f f` would
        // print `a; echo b` for `{ echo a; echo b }`.
        // c:Src/parse.c:1690-1706 — par_funcdef requires a clean
        //   body-opener brace when the anonymous form `function {body}`
        //   is used (no names AND no `()`). zsh's lexer keeps the `{`
        //   as its own STRING token via the lex.c:1141-1144 early-
        //   return at command position, but the body brace must be
        //   followed by whitespace for the inner par_list to find a
        //   matching OUTBRACE — without a separator, the closing `}`
        //   gets merged into the last word (`X}`) and par_list ends
        //   without OUTBRACE, which C zsh reports as `parse error near
        //   \`}'`. zshrs's lexer has the same `bct` semantics; reject
        //   here at the parse step so the funcdef doesn't silently run
        //   with the stray `}` attached. With names or `()` present,
        //   the body brace is allowed even without a separator
        //   (`function name {body}` and `function () {body}` both work
        //   in zsh). Bug #60 in docs/BUGS.md.
        if names.is_empty() && !saw_paren {
            // Check the source byte IMMEDIATELY after the `{`. Tokenizing the
            // brace leaves `pos()` at `{`+2 — the lexer consumes the brace AND
            // the one separator char behind it — so that byte lives at
            // `pos() - 1`, NOT at `pos()`. Reading `pos()` looked one byte too
            // far and hit the first BODY character whenever exactly ONE space
            // followed the brace, so `function { echo x }` was rejected as
            // malformed while `function {  echo x }` (two spaces, leaving a
            // second space under the peek) parsed. Both are valid in zsh.
            //
            // The genuinely malformed `function {body}` never reaches here:
            // with no separator the lexer folds `{body` into a single STRING
            // word instead of emitting a brace token, so this branch is not
            // taken and the parse fails downstream — which is what zsh does
            // too (`parse error near `}'`). Bug #60 in docs/BUGS.md.
            let next_byte = pos()
                .checked_sub(1)
                .and_then(|p| input_slice(p, pos()))
                .and_then(|s| s.bytes().next())
                .unwrap_or(b' ');
            if !matches!(next_byte, b' ' | b'\t' | b'\n' | b';') {
                // c:1735 YYERRORV(oecused) — par_event's yyerror names
                // zshlextext (`function {` at end of input → near `{').
                set_tok(LEXERR); // c:87 `tok = LEXERR`
                return None;
            }
        }
        crate::funcdef_capture::body_mark_restart(&mut body_mark);
        zshlex();
        // c:Src/parse.c — func body terminates at OUTBRACE_TOK.
        // Explicit end-token keeps the inner parse from hitting the
        // top-level stray-`}` arm (#168). Bug #167 family.
        let body = parse_program_until(Some(&[OUTBRACE_TOK]), false);
        // c:Src/parse.c:1733-1737 — `if (tok != OUTBRACE) { cmdpop();
        // ... YYERRORV(oecused); }`. Hard-error on missing close brace
        // so `function f { echo hi` doesn't silently register a half-
        // parsed body. Bug #405.
        if tok() != OUTBRACE_TOK {
            set_tok(LEXERR); // c:87 YYERRORV(oecused) — no own message
            return None;
        }
        // See the matching `NAME ()` arm below and Bug #642: slice
        // through pos() so the funcdef `}` is always inside the slice
        // (at EOF `pos()-1` excluded it), then strip that single trailing
        // brace — so a body ending in a balanced `} always { ... }` keeps
        // its close on the `.zwc` round-trip.
        let body_source = crate::funcdef_capture::body_text(body_mark)
            .map(|s| {
                let t = s.trim();
                // Strip the statement SEPARATOR that followed the funcdef
                // `}` FIRST — for `name() { body }; next` the slice ends in
                // `};`, so stripping the brace before the `;` left the `}`
                // stranded (`${functions[name]}` → `body }`, then re-parsed
                // to a `parse error near '}'`). Order: trailing separators →
                // closing brace → the body's own last-statement separator.
                let t = t.trim_end_matches(|c: char| c == ';' || c == '\n' || c.is_whitespace());
                let t = t.strip_suffix('}').unwrap_or(t).trim_end();
                let t = t
                    .trim_end_matches(|c: char| c == ';' || c == '\n')
                    .trim_end();
                t.to_string()
            })
            .filter(|s| !s.is_empty());
        // c:Src/parse.c par_funcdef bakes alias expansion into the wordcode; see
        // vm_helper::funcdef_note_resolved_body.
        crate::vm_helper::funcdef_note_resolved_body(body_source.as_deref());
        zshlex();

        // Anonymous form `function () { body } a b c` (with `()`) or
        // `function { body } a b c` (zsh-only shorthand, no `()`). No
        // name was collected. Mirror parse_anon_funcdef: synthesize
        // `_zshrs_anon_N`, collect trailing args, set auto_call_args
        // so compile_funcdef registers + immediately calls the
        // function with the args as positional params.
        if names.is_empty() {
            let mut args = Vec::new();
            while tok() == STRING_LEX {
                if let Some(s) = tokstr() {
                    args.push(s);
                }
                zshlex();
            }
            static ANON_COUNTER: AtomicUsize = AtomicUsize::new(0);
            let n = ANON_COUNTER.fetch_add(1, Ordering::Relaxed);
            let name = format!("_zshrs_anon_kw_{}", n);
            return Some(ZshCommand::FuncDef(ZshFuncDef {
                names: vec![name],
                body: Box::new(body),
                tracing,
                keyword_form: true,
                auto_call_args: Some(args),
                body_source,
            }));
        }

        Some(ZshCommand::FuncDef(ZshFuncDef {
            names,
            body: Box::new(body),
            tracing,
            keyword_form: true,
            auto_call_args: None,
            body_source,
        }))
    } else if unset(SHORTLOOPS) {
        // c:Src/parse.c:1742 — `else if (unset(SHORTLOOPS)) YYERRORV`.
        // Braceless short body (`function f () CMD`) requires SHORTLOOPS.
        set_tok(LEXERR); // c:1746 YYERRORV(oecused)
        None
    } else {
        // c:Src/parse.c:1747-1748 — `else par_list1(&c)`. The short body
        // is ONE sublist (a single command), NOT a full list. The prior
        // `par_list(false)` greedily consumed past the `;` (so `function
        // foo () print bar; foo` swallowed the trailing `foo` call and
        // errored "parse error near `foo'"). Use par_cmd for the single
        // command, matching the brace-less `foo() CMD` path
        // (parse_inline_funcdef). Bug surface: C04funcdef `function foo ()
        // print bar`.
        // Slice the raw short-body text (unbraced_body_start was captured
        // before the body token was lexed, above) so `functions`/`typeset -f`
        // can list it (fusevm shfuncs render from this raw `body`, not
        // getpermtext — hashtable.rs:1397). Without it `function f () print x`
        // listed as `f () { }` (empty).
        par_cmd(false).map(|cmd| {
            let body_source = crate::funcdef_capture::body_text(body_mark)
                .map(|s| {
                    s.trim()
                        .trim_end_matches(|c: char| c == ';' || c == '\n' || c.is_whitespace())
                        .to_string()
                })
                .filter(|s| !s.is_empty());
            // c:Src/parse.c par_funcdef bakes alias expansion into the wordcode; see
            // vm_helper::funcdef_note_resolved_body.
            crate::vm_helper::funcdef_note_resolved_body(body_source.as_deref());
            let list = ZshList {
                sublist: ZshSublist {
                    pipe: ZshPipe {
                        cmd,
                        next: None,
                        lineno: lineno(),
                        merge_stderr: false,
                    },
                    next: None,
                    flags: SublistFlags::default(),
                },
                flags: ListFlags::default(),
            };
            ZshCommand::FuncDef(ZshFuncDef {
                names,
                body: Box::new(ZshProgram { lists: vec![list] }),
                tracing,
                keyword_form: true,
                auto_call_args: None,
                body_source,
            })
        })
    }
}

/// Port of `par_time()` from `Src/parse.c:1787` — C decl `par_time(void)`. AST variant: builds `ZshCommand::Time` instead of WCB_TIMED.
/// Parse time command
/// Parse `time CMD` (POSIX time keyword). Direct port of
/// zsh/Src/parse.c:1787 `par_time`. The `time` keyword
/// times the execution of the following pipeline / cmd.
fn par_time() -> Option<ZshCommand> {
    zshlex(); // skip 'time'

    // Check if there's a pipeline to time
    if tok() == SEPER || tok() == NEWLIN || tok() == ENDINPUT {
        Some(ZshCommand::Time(None))
    } else {
        let sublist = par_sublist();
        Some(ZshCommand::Time(sublist.map(Box::new)))
    }
}

/// Port of `par_dinbrack()` from `Src/parse.c:1810` — C signature `par_dinbrack(void)`. Body
/// parser inside `[[ ... ]]` — calls `par_cond` to emit the
/// condition wordcode then advances past `]]`.
pub fn par_dinbrack() -> Option<()> {
    // c:1810
    let oecused = ECUSED.get(); // c:1812 `int oecused = ecused;`
    set_incond(1); // c:1814
    set_incmdpos(false); // c:1815
    zshlex(); // c:1816
    let _ = par_cond(); // c:1817
    if tok() != DOUTBRACK {
        // c:1818
        // c:1819 — `YYERROR(oecused);`
        set_tok(LEXERR);
        ECUSED.set(oecused);
        return None;
    }
    set_incond(0); // c:1820
    set_incmdpos(true); // c:1821
    zshlex(); // c:1822
    Some(())
}

/// Port of `par_simple()` from `Src/parse.c:1836` — C decl `par_simple(int *cmplx, int nr)`. AST variant.
/// Parse a simple command
/// Parse a simple command (assignments + words + redirections).
/// Direct port of zsh/Src/parse.c:1836 `par_simple` —
/// the largest single function in parse.c. Handles ENVSTRING/
/// ENVARRAY assignments at command head, intermixed redirs,
/// typeset-style multi-assignment commands, and the trailing
/// inout-par `()` that converts a simple command into an inline
/// function definition.
fn par_simple(mut redirs: Vec<ZshRedir>) -> Option<ZshCommand> {
    let mut typeset_reswd = false;
    // zshrs-only: the alias the command word (not an argument) came out of.
    let mut first_word_alias: Option<(String, usize)> = None;
    let mut assigns = Vec::new();
    let mut words = Vec::new();
    // c:1840 — `char *hasalias = input_hasalias();` — the alias (if any)
    // whose expansion the FIRST word of this command came out of. Refreshed
    // (only while still NULL) after every word-lexing zshlex at c:1916-1917 /
    // 1950-1951 / 1995-1996 / 2025-2026.
    let mut hasalias: Option<String> = crate::ported::input::input_hasalias();

    // c:1934-1974 — `{var}>file` brace-FD detection is wired
    // INSIDE the words loop below (parse.rs:4940-4956) rather than
    // here at the head. The words-loop site sees the tok=STRING
    // `{varname}` followed by a REDIROP and routes into par_redir
    // with redir.varid populated. C does it inline at the start of
    // each STRING/TYPESET arm iteration; functionally equivalent.

    // c:1843-1846 — leading-NOCORRECT prefix: `nocorrect echo hello`
    // emits a NOCORRECT token at the start of par_simple. C sets
    // `nocorrect = 1` and skips past via the `zshlex();` at the
    // for-loop tail (c:1907). zshrs's par_simple (AST) had no
    // NOCORRECT arm so the token was silently dropped and the
    // following command line evaporated — `nocorrect echo hello`
    // produced empty output.
    //
    // c:1844-1907 — ONE loop takes NOCORRECT and the leading assignments in
    // any order, so `z=1 nocorrect cmd` is as valid as `nocorrect z=1 cmd`.
    // Two consecutive loops (NOCORRECT first) rejected the former with a
    // parse error.
    loop {
        if tok() == NOCORRECT {
            set_nocorrect(1); // c:1846
            zshlex(); // c:1907 (loop-tail zshlex)
            continue;
        }
        if tok() != ENVSTRING && tok() != ENVARRAY {
            break; // c:1905-1906
        }
        if let Some(assign) = parse_assign() {
            // c:1856-1865 — the name is NUL-terminated inside tokstr.
            if tok() == ENVSTRING {
                // !!! RUST-ONLY !!! — C NUL-terminates the name INSIDE tokstr, and
                // `zshlextext` is that same buffer (lex.c:1980/2018). zshlex does not
                // refresh it at ENDINPUT (c:276 skips exalias), so a parse error at end
                // of input right after an assignment names only the name (`f() { x=1}`
                // → near `x'). LEX_ZSHLEXTEXT is an owned copy; write the cut through.
                crate::ported::lex::LEX_ZSHLEXTEXT.with_borrow_mut(|t| {
                    if let Some(text) = t.as_mut().filter(|text| text.starts_with(assign.name.as_str())) {
                        text.truncate(assign.name.len());
                    }
                });
            }
            assigns.push(assign);
        }
        zshlex();
    }

    // Parse words and redirections
    loop {
        // c:1916-1917 — `zshlex(); if (!hasalias) hasalias =
        // input_hasalias();` — C refreshes after every word-lexing advance.
        // The previous advance happened at the tail of the last iteration
        // (or in the caller for the first token), so the top of the loop is
        // the equivalent observation point.
        if hasalias.is_none() {
            hasalias = crate::ported::input::input_hasalias();
        }
        match tok() {
            ENVSTRING | ENVARRAY if words.is_empty() => {
                // c:1843-1907 — still in command position (no command
                // word collected yet): a `name=val` token here is a
                // PRE-COMMAND assignment, even when it follows a
                // redirection (`a=b 2>/dev/null c=d`). C's single
                // par_simple loop collects assignments and redirs in any
                // order until the command word; zshrs split that into a
                // leading-assignments while-loop (above) plus this main
                // loop, and the leading loop stopped at the first redir.
                // Without this arm the trailing `c=d` fell into the
                // typeset-word path below and was silently dropped, so
                // `a=b 2>/dev/null c=d` set neither parameter.
                if let Some(assign) = parse_assign() {
                    // c:1856-1865 — the name is NUL-terminated inside tokstr.
                    if tok() == ENVSTRING {
                        // !!! RUST-ONLY !!! — write the cut through to zshlextext (see the
                        // leading-assignment loop in par_simple).
                        crate::ported::lex::LEX_ZSHLEXTEXT.with_borrow_mut(|t| {
                            if let Some(text) = t.as_mut().filter(|text| text.starts_with(assign.name.as_str())) {
                                text.truncate(assign.name.len());
                            }
                        });
                    }
                    assigns.push(assign);
                }
                zshlex();
            }
            ENVSTRING | ENVARRAY => {
                // Mid-command assignment-shape arg under typeset
                // / declare / local / etc. (intypeset gates the
                // lexer to emit Envstring/Envarray for `name=val`
                // and `name=()` past the command name). Parse the
                // assignment, then emit a synthetic word
                // `NAME=value` (scalar) or `NAME=( … )` (array)
                // string so typeset's builtin arg list sees the
                // assignment-shape arg. Avoids the inline-env
                // scope path that mistakenly treats it like a
                // pre-cmd `X=Y cmd` assignment.
                if let Some(assign) = parse_assign() {
                    // c:2010-2019 — the mid-command scan has no `+=` arm, so
                    // `equalsplit` NUL-terminates at the `=` and the `+`
                    // stays part of the name left in tokstr. c:2032 likewise
                    // `ecstr(tokstr)`s an ENVARRAY name whole. typeset_single
                    // then rejects `x+` ("not valid in this context"); the
                    // synthetic word dropped the `+` and assigned instead.
                    let nul_at = if assign.append {
                        format!("{}+", assign.name)
                    } else {
                        assign.name.clone()
                    };
                    if tok() == ENVSTRING {
                        // !!! RUST-ONLY !!! — write the cut through to zshlextext (see the
                        // leading-assignment loop in par_simple).
                        crate::ported::lex::LEX_ZSHLEXTEXT.with_borrow_mut(|t| {
                            if let Some(text) = t.as_mut().filter(|text| text.starts_with(nul_at.as_str())) {
                                text.truncate(nul_at.len());
                            }
                        });
                    }
                    let synthetic = match &assign.value {
                        ZshAssignValue::Scalar(v) => format!("{}={}", nul_at, v),
                        ZshAssignValue::Array(elems) => {
                            // c:Src/builtin.c — assoc paren-init `h=( "" v
                            //   k2 v2 )` must preserve empty-string
                            //   elements (zsh stores key="" + value="v").
                            //   The bin_typeset paren-init splitter at
                            //   `builtin.rs:4358` recognizes the
                            //   REJOIN_SEP (`\u{1f}`) sentinel between
                            //   array elements and skips the leading/
                            //   trailing parens trim; using it here
                            //   round-trips empties end-to-end through
                            //   the synthetic-arg rebuild. Space-join
                            //   collapses adjacent empties (`(` + `""` +
                            //   `empty-val` becomes `( empty-val`) so
                            //   bin_typeset never sees the empty key.
                            //   Bug #93 in docs/BUGS.md.
                            let mut buf = String::with_capacity(
                                nul_at.len()
                                    + 4
                                    + elems.iter().map(|e| e.len() + 1).sum::<usize>(),
                            );
                            buf.push_str(&nul_at);
                            buf.push_str("=(");
                            for elem in elems {
                                buf.push('\u{1f}');
                                buf.push_str(elem);
                            }
                            buf.push('\u{1f}');
                            buf.push(')');
                            buf
                        }
                    };
                    words.push(synthetic);
                }
                zshlex();
            }
            STRING_LEX | TYPESET => {
                if words.is_empty() {
                    first_word_alias =
                        crate::intercepts::alias_origin(crate::ported::input::input_hasalias());
                }
                // c:1931-1932 — the reserved-word head decides WC_TYPESET.
                if words.is_empty() && tok() == TYPESET {
                    typeset_reswd = true;
                }
                let s = tokstr();
                if let Some(s) = s {
                    words.push(s);
                }
                // c:1929 — `incmdpos = 0;` so the next zshlex() does
                // not re-promote `{`/`[[`/reserved words at the
                // continuation position. Without this, `echo {a,b}`
                // re-lexes `{` as INBRACE_TOK (current-shell block)
                // and the brace expansion never reaches par_simple.
                set_incmdpos(false);
                // c:1931-1932 — `if (tok == TYPESET) intypeset = is_typeset = 1;`
                // Multi-assign `typeset a=1 b=2` relies on the lexer
                // re-emitting `b=2` as ENVSTRING; that path is gated
                // on `intypeset`. Without this, follow-on assignment
                // words arrive as STRING and the typeset builtin's
                // multi-assign form silently degrades.
                if tok() == TYPESET {
                    set_intypeset(true);
                }
                zshlex();
                // c:1950-1951 — `if (!hasalias) hasalias = input_hasalias();`
                if hasalias.is_none() {
                    hasalias = crate::ported::input::input_hasalias();
                }
                // Check for function definition foo() { ... }
                if words.len() == 1 && tok() == INOUTPAR {
                    // c:2058-2060 — `/* Error if preceding assignments */
                    // if (assignments || postassigns) YYERROR(oecused);` —
                    // `x=1 f() { … }` is a parse error, not a definition.
                    if !assigns.is_empty() {
                        set_tok(LEXERR); // c:2060 YYERROR(oecused)
                        return None;
                    }
                    // The ALIAS_FUNC_DEF gate applies to EVERY route into the
                    // funcdef body, not just the match arm below; this early
                    // return is the single-word shape.
                    // c:2061-2068 — `if
                    // (isset(EXECOPT) && hasalias && !isset(ALIASFUNCDEF) &&
                    // argc && hasalias != input_hasalias()) {
                    // zwarn("defining function based on alias `%s'",
                    // hasalias); YYERROR(oecused); }`
                    //
                    // 5.9.2 parse.c:2057-2061 is just `zwarn(...); YYERROR(oecused);` — no herrflush/errflag
                    // (the dev tree adds them), so yyerror still reports `parse error near `()'` after the warning.
                    if isset(EXECOPT)
                        && hasalias.is_some()
                        && !isset(ALIASFUNCDEF)
                        && words.len() != 0
                        && hasalias != crate::ported::input::input_hasalias()
                    {
                        crate::ported::utils::zwarn(&format!(
                            // c:2058
                            "defining function based on alias `{}'",
                            hasalias.as_deref().unwrap_or("")
                        ));
                        set_tok(LEXERR); // c:2067 YYERROR
                        return None;
                    }
                    return parse_inline_funcdef(std::mem::take(&mut words));
                }
                // `{name}>file` named-fd redirect: the lexer doesn't
                // recognize this shape, so the bare word `{name}`
                // arrives as a String. If it matches `{IDENT}` and
                // the NEXT token is a redirop, pop it off as the
                // varid for that redir.
                if !words.is_empty() && IS_REDIROP(tok()) {
                    let last = words.last().unwrap();
                    let untoked = super::lex::untokenize(last);
                    if untoked.starts_with('{') && untoked.ends_with('}') && untoked.len() > 2 {
                        let name = &untoked[1..untoked.len() - 1];
                        // c:1944 — `if (itype_end(tokstr+1, IIDENT, 0) >= ptr)`:
                        // every char between the braces must be an IIDENT char.
                        // IIDENT (utils.c:4173/4190) covers digits, letters and
                        // `_` — with NO first-char restriction, so an all-digit
                        // name like `{1}` (a positional param, used by p10k's
                        // `exec {1}>&-`) is a valid fd var. The prior check also
                        // required the first char to be `_`/alphabetic, which
                        // rejected `{1}`/`{2}`/`{12}` — zsh accepts them.
                        if !name.is_empty() && name.bytes().all(crate::ported::ztype_h::iident) {
                            let varid = name.to_string();
                            words.pop();
                            if let Some(mut redir) = par_redir() {
                                redir.varid = Some(varid);
                                redirs.push(redir);
                            }
                            continue;
                        }
                    }
                }
            }
            _ if IS_REDIROP(tok()) => {
                match par_redir() {
                    Some(redir) => redirs.push(redir),
                    None => break, // Error in redir parsing, stop
                }
            }
            INOUTPAR if !words.is_empty() => {
                // c:2055-2057 — `if (!isset(MULTIFUNCDEF) && argc > 1)
                // YYERROR(oecused);` — multi-name funcdef gate:
                // `f1 f2() { ... }` defines f1 AND f2 to the same
                // body, but only when MULTIFUNCDEF is set.
                if !isset(MULTIFUNCDEF) && words.len() > 1 {
                    set_tok(LEXERR); // c:2057 YYERROR(oecused)
                    return None;
                }
                // c:2058-2060 — `/* Error if preceding assignments */ if
                // (assignments || postassigns) YYERROR(oecused);` —
                // `x=1 f() { … }` is a parse error, not a definition.
                if !assigns.is_empty() {
                    set_tok(LEXERR); // c:2060 YYERROR(oecused)
                    return None;
                }
                // c:2061-2068 — `if
                // (isset(EXECOPT) && hasalias && !isset(ALIASFUNCDEF) &&
                // argc && hasalias != input_hasalias()) {
                // zwarn("defining function based on alias `%s'", hasalias);
                // YYERROR(oecused); }`
                //
                // 5.9.2 parse.c:2057-2061 is just `zwarn(...); YYERROR(oecused);` — no herrflush/errflag
                // (the dev tree adds them), so yyerror still reports `parse error near `()'` after the warning.
                if isset(EXECOPT)
                    && hasalias.is_some()
                    && !isset(ALIASFUNCDEF)
                    && words.len() != 0
                    && hasalias != crate::ported::input::input_hasalias()
                {
                    crate::ported::utils::zwarn(&format!(
                        // c:2058
                        "defining function based on alias `{}'",
                        hasalias.as_deref().unwrap_or("")
                    ));
                    set_tok(LEXERR); // c:2067 YYERROR
                    return None;
                }
                // foo() { ... } / multi-name `f1 f2 f3() { ... }` style
                // function. c:Src/parse.c:2055-2068 — under MULTIFUNCDEF
                // every preceding word names the SAME body; pass them all
                // so each is registered (the gate above already rejected
                // multi-name without MULTIFUNCDEF). Previously only the
                // last word (`words.pop()`) was defined, so `f1 f2 f3()
                // {...}` left f1/f2 as "command not found".
                return parse_inline_funcdef(std::mem::take(&mut words));
            }
            _ => break,
        }
    }

    if assigns.is_empty() && words.is_empty() && redirs.is_empty() {
        return None;
    }

    Some(ZshCommand::Simple(ZshSimple {
        assigns,
        words,
        redirs,
        typeset_reswd,
        via_alias: first_word_alias,
    }))
}

/// Port of `par_redir()` from `Src/parse.c:2229` — C decl `par_redir(int *rp, char *idstring)`. AST variant; the body lives in `par_redir_with_id` (C's `idstring` parameter).
/// Parse a redirection
/// Parse a redirection (>file, <file, >>file, <<HEREDOC, etc.).
/// Direct port of zsh/Src/parse.c:2229 `par_redir`. Returns
/// a ZshRedir node carrying the operator type, fd, target word
/// (or here-doc body / pipe-redir command), and any `{var}` style
/// fd-binding parameter.
fn par_redir() -> Option<ZshRedir> {
    par_redir_with_id(None)
}

/// Wire a here-document body onto the redirection token that
/// requested it. Direct port of zsh/Src/parse.c:2347
/// `setheredoc`. Called when a heredoc terminator has been
/// matched and the body is ready to be attached to the redir.
///
/// zshrs port note: zsh's setheredoc patches the wordcode
/// in-place via `pc[1] = ecstrcode(doc); pc[2] = ecstrcode(term);`.
/// zshrs threads heredoc bodies through `HereDocInfo` structs
/// attached inline during the post-parse `fill_heredoc_bodies` walk.
/// This method is the AST-side equivalent: writes back to the
/// matching redir node by index.
/// Port of `setheredoc()` from `Src/parse.c:2347` — C decl `setheredoc(int pc, int type, char *str, char *termstr, char *munged_termstr)`. AST variant: writes back into the `ZshRedir` node instead of patching `ecbuf`.
/// Patches the
/// pending heredoc redir at `pc` with its body string + raw and
/// munged terminator forms.
pub fn setheredoc(pc: usize, redir_type: i32, doc: &str, term: &str, munged_term: &str) {
    // zshrs-only guard: AST-path heredocs use `pc = -1 as usize`
    // (i.e. `usize::MAX`) as a sentinel meaning "no wordcode slot to
    // patch". C never passes a negative pc since the wordcode emitter
    // is always active. Skip silently for the AST-only case.
    if pc == usize::MAX {
        return;
    }
    // c:2350 — `int varid = WC_REDIR_VARID(ecbuf[pc]) ? REDIR_VARID_MASK : 0;`
    let cur = ECBUF.with_borrow(|b| b.get(pc).copied().unwrap_or(0));
    let varid = if WC_REDIR_VARID(cur) != 0 {
        REDIR_VARID_MASK
    } else {
        0
    };
    // c:2351 — `ecbuf[pc] = WCB_REDIR(type | REDIR_FROM_HEREDOC_MASK | varid);`
    let new_header = WCB_REDIR((redir_type | REDIR_FROM_HEREDOC_MASK | varid) as wordcode);
    // c:2352 — `ecbuf[pc + 2] = ecstrcode(str);`
    let coded_str = ecstrcode(doc);
    // c:2353 — `ecbuf[pc + 3] = ecstrcode(termstr);`
    let coded_term = ecstrcode(term);
    // c:2354 — `ecbuf[pc + 4] = ecstrcode(munged_termstr);`
    let coded_munged = ecstrcode(munged_term);
    ECBUF.with_borrow_mut(|b| {
        b[pc] = new_header;
        b[pc + 2] = coded_str;
        b[pc + 3] = coded_term;
        b[pc + 4] = coded_munged;
    });
}

/// Port of `par_wordlist()` from `Src/parse.c:2362` — C decl `par_wordlist(void)`. AST variant: returns the words instead of `ecstr`-ing them.
/// Parse a wordlist for `for ... in WORDS;`. Direct port of
/// zsh/Src/parse.c:2362 `par_wordlist`. Reads STRING tokens
/// until the next SEPER / SEMI / NEWLIN.
pub fn par_wordlist() -> Vec<String> {
    let mut out = Vec::new();
    // parse.c:2362-2378 — collect STRINGs into the wordlist.
    while tok() == STRING_LEX {
        if let Some(text) = tokstr() {
            out.push(text);
        }
        zshlex();
    }
    out
}

/// Port of `par_nl_wordlist()` from `Src/parse.c:2379` — C decl `par_nl_wordlist(void)`. AST variant.
/// Parse a newline-separated wordlist. Direct port of
/// zsh/Src/parse.c:2379 `par_nl_wordlist`. Like
/// par_wordlist but tolerates leading/trailing newlines.
pub fn par_nl_wordlist() -> Vec<String> {
    // parse.c:2380-2381 — skip leading newlines.
    while tok() == NEWLIN {
        zshlex();
    }
    let out = par_wordlist();
    // parse.c:2395-2397 — skip trailing newlines.
    while tok() == NEWLIN {
        zshlex();
    }
    out
}

/// Port of `COND_SEP()` from `Src/parse.c:2405` — C decl `#define COND_SEP() (tok == SEPER && condlex != testlex && *zshlextext != ';')`. C macro.
/// `COND_SEP()` macro from `Src/parse.c:2405`:
///   `(tok == SEPER && condlex != testlex && *zshlextext != ';')`
/// A newline (but NOT a `;`) between cond terms inside `[[ … ]]` is
/// skippable whitespace; a `;` is a parse error (`[[ a ; ]]`).
///
/// zshrs has two lexer modes feeding the two cond parsers:
///   - wordcode path (autoload / parse_string): LEXFLAGS_NEWLINE off,
///     so a newline is FOLDED to SEPER (lex.rs:265). C's `[[ a &&\n b ]]`
///     lands here; matching only NEWLIN missed it → "condition
///     expected" (broke every multi-line `&&`/`||` cond in compinit and
///     the compsys completers).
///   - AST path (`-c`, source): LEXFLAGS_NEWLINE on, newline stays
///     NEWLIN (unfolded).
/// `;` ALWAYS folds to SEPER (lex.rs:265, unconditional for SEMI) with
/// LEX_ISNEWLIN==0, so gating the SEPER arm on LEX_ISNEWLIN!=0
/// reproduces C's `*zshlextext != ';'` exclusion in both modes.
#[inline]
pub fn COND_SEP() -> bool {
    // c:2403 — `condlex != testlex`: the test-mode lexer never yields SEPER.
    if CONDLEX_TESTLEX.get() {
        return false;
    }
    match tok() {
        NEWLIN => true,
        SEPER => crate::ported::lex::LEX_ISNEWLIN.with(|c| c.get()) != 0,
        _ => false,
    }
}

/// Port of `par_cond()` from `Src/parse.c:2409` — C decl `par_cond(void)`. AST variant. It also inlines `par_dinbrack`'s wrapper (c:1810-1822): `incond`/`incmdpos` set, `[[` skipped, `]]` required.
/// Parse [[ ... ]] conditional
/// Parse `[[ EXPR ]]` conditional expression. Direct port of
/// zsh/Src/parse.c:2409 `par_cond` (and helpers par_cond_1,
/// par_cond_2, par_cond_double, par_cond_triple, par_cond_multi
/// at parse.c:2434-2731). Expression operators: `||` `&&` `!`
/// + unary tests (-f, -d, -n, -z, etc.) + binary tests (=, !=,
///   <, >, ==, =~, -eq, -ne, -lt, -le, -gt, -ge, -nt, -ot, -ef).
fn par_cond() -> Option<ZshCommand> {
    // C par_dinbrack (parse.c:1810-1822) wraps the body parse with
    // `incond = 1; incmdpos = 0;` BEFORE the first zshlex past `[[`,
    // and resets to `incond = 0; incmdpos = 1;` after `]]`. Without
    // `incond = 1`, lex.c does not promote `]]` to DOUTBRACK and the
    // cond body bleeds past the close bracket — the parser then
    // sees `]]` as a separate STRING command. Every `if [[ ... ]]; then`
    // failed with `command not found: ]]` before this fix.
    set_incond(1);
    set_incmdpos(false);
    zshlex(); // skip [[
              // c:1817 — no empty-cond special case here. `]]` reaches
              // par_cond_2 as a DOUTBRACK that still carries its tokstr
              // (lex.c:2010-2012 retypes the STRING in place), so
              // c:2553-2560 re-reads it as `[[ -n "]]" ]]` and the
              // MISSING `]]` is what fails, one token later — which is
              // why zsh reports `[[ ]];` near `;' and `[[ ]] print`
              // near `print', not near `]]'.
    let cond = parse_cond_expr();

    if tok() == DOUTBRACK {
        set_incond(0);
        set_incmdpos(true);
        zshlex();
    } else {
        // c:Src/parse.c:1818-1819 — `if (tok != DOUTBRACK)
        // YYERRORV(oecused);`. par_dinbrack hard-requires DOUTBRACK
        // after par_cond; anything else is a parse error and the
        // outer parser's yyerror at c:2747 emits `parse error near
        // \`%s'` using zshlextext. Bug #473: BAR (`|`) inside
        // `[[ ab == a|b ]]` slipped past par_cond_or (which only
        // checks DBAR), the cond returned cleanly, and then the
        // top-level parser interpreted BAR as a pipe — running `b`
        // as a command (security-relevant if pattern RHS is user
        // input). Mirror C: emit parse error and abort.
        // c:1819 YYERRORV → tok = LEXERR, and the top-level parse
        // (c:673/708) calls yyerror once, which derives the token text
        // from `zshlextext` — tokstr when the token captured one, else
        // `tokstrings[tok]` (lex.c:1965). The port's yyerror already
        // does both, so hand-rolling a token-name table here only
        // produced a second, differently-worded message.
        yyerror(0);
        set_incond(0);
        set_incmdpos(true);
        return None;
    }

    cond.map(ZshCommand::Cond)
}

/// Port of `par_cond_1()` from `Src/parse.c:2434` — C signature `par_cond_1(void)`. Parses one
/// `||`-separated cond expression. Emits `WCB_COND(COND_AND, …)`
/// when an `&&` is found and recurses.
pub fn par_cond_1() -> i32 {
    // c:2434

    let p = ECUSED.with(|c| c.get()) as usize;
    let r = par_cond_2();
    while COND_SEP() {
        condlex();
    }
    if tok() == DAMPER {
        condlex();
        while COND_SEP() {
            condlex();
        }
        ecispace(p, 1);
        par_cond_1();
        let ecused = ECUSED.with(|c| c.get()) as usize;
        ECBUF.with(|c| {
            c.borrow_mut()[p] = WCB_COND(COND_AND as u32, (ecused - 1 - p) as u32);
        });
        return 1;
    }
    r
}

/// Port of `par_cond_2()` from `Src/parse.c:2476` — C signature `par_cond_2(void)`. The heavy
/// cond-term parser: handles `! cond`, `(cond)`, unary `[ -X arg ]`,
/// binary `[ A op B ]`, and `[ A op1 B op2 C … ]` n-ary chains.
pub fn par_cond_2() -> i32 {
    // c:2476
    // c:2480 — `(condlex == testlex) ? arrlen(testargs) + 1 : 0`. C's
    // `testargs` is a pointer into the argv; here it is an index into
    // `TESTARGS`, so `arrlen(testargs)` is the length less that index.
    let n_testargs: i32 = if CONDLEX_TESTLEX.get() {
        crate::ported::builtin::TESTARGS
            .with_borrow(|a| a.len() - crate::ported::builtin::TESTARGS_IDX.get())
            as i32
            + 1
    } else {
        0
    };
    // C's `*testargs`: the argument after the current token, `None` where C
    // sees the argv's NULL terminator.
    let next_testarg = || -> Option<String> {
        crate::ported::builtin::TESTARGS
            .with_borrow(|a| a.get(crate::ported::builtin::TESTARGS_IDX.get()).cloned())
    };

    if n_testargs != 0 {
        // c:2482 — See the description of test in POSIX 1003.2.
        if tok() == crate::ported::zsh_h::NULLTOK {
            // c:2485 — no arguments: false.
            return par_cond_double("-n", "");
        }
        if n_testargs == 1 {
            // c:2487 — one argument: `[ foo ]` is equivalent to `[ -n foo ]`.
            let s1 = tokstr().unwrap_or_default();
            condlex();
            // c:2492 — ksh behavior: `[ -t ]` means `[ -t 1 ]`; bash disagrees.
            if unset(POSIXBUILTINS) && check_cond(&s1, "t") {
                return par_cond_double(&s1, "1");
            }
            return par_cond_double("-n", &s1);
        }
        if n_testargs > 2 {
            // c:2496 — three arguments: if the second argument is a binary
            // operator, perform that binary test on the first and third.
            let nx = next_testarg().unwrap_or_default();
            let mut nxc = nx.chars();
            if nx == "="
                || nx == "<"
                || nx == ">"
                || nx == "=="
                || nx == "!="
                || (nxc.next().map_or(false, IS_DASH) && get_cond_num(nxc.as_str()) >= 0)
            {
                let s1 = tokstr().unwrap_or_default(); // c:2505
                condlex();
                let s2 = tokstr().unwrap_or_default(); // c:2507
                condlex();
                let s3 = tokstr().unwrap_or_default(); // c:2509
                condlex();
                return par_cond_triple(&s1, &s2, &s3); // c:2511
            }
        }
        // c:2514-2516 — we fall through here on any non-numeric infix
        // operator or any other time there are at least two arguments.
    } else {
        while COND_SEP() {
            condlex();
        }
    }
    if tok() == BANG_TOK {
        // c:2521-2524 — in "test" compatibility mode, `! -a ...` and
        // `! -o ...` are treated as `[string] [and] ...` / `[string] [or] ...`.
        let nx = next_testarg();
        if !(n_testargs > 2
            && nx
                .as_deref()
                .map_or(false, |t| check_cond(t, "a") || check_cond(t, "o")))
        {
            // c:2528 — `[[ ! cond ]]`
            condlex();
            ecadd(WCB_COND(COND_NOT as u32, 0));
            return par_cond_2();
        }
    }
    if tok() == INPAR_TOK {
        // c:2533 — `[[ (cond) ]]`. Recurse into the WORDCODE cond OR-chain
        // `par_cond_top` (C's `par_cond`, parse.c:2409). The bare `par_cond`
        // in this crate is the AST `[[ ]]` parser — it opens with
        // `zshlex(); // skip [[`, so calling it here consumed the FIRST term
        // of the group (e.g. the `-z` in `[[ ( -z x ) ]]`) as if it were the
        // `[[`, then failed. Every parenthesised sub-condition parsed via
        // parse_string (autoload's function-body parse, `.zcompdump`, etc.)
        // hit `parse error`, which broke compinit/compaudit and thus all of
        // compsys.
        condlex();
        while COND_SEP() {
            condlex();
        }
        let r = par_cond_top();
        while COND_SEP() {
            condlex();
        }
        if tok() != OUTPAR_TOK {
            YYERROR!(ECUSED.get()); // c:2544 `YYERROR(ecused);`
        }
        condlex();
        return r;
    }
    let s1 = tokstr().unwrap_or_default();
    // c:2549 — `dble = (s1 && IS_DASH(*s1) && (!n_testargs ||
    // strspn(s1+1, "abcd...") == 1) && !s1[2]);` — IS_DASH covers
    // BOTH `-` and Dash (`\u{e19b}`). The raw tokstr inside `[[ ... ]]`
    // carries Dash as a marker byte, so `starts_with('-')` alone
    // matches only ASCII dashes and misses every `-z`, `-d`, `-r`
    // etc. — every such cond emitted the AST-only `condition
    // expected` error from par_cond_double. Use IS_DASH and count
    // chars (Dash is a single code point) instead of bytes.
    let s1_chars: Vec<char> = s1.chars().collect();
    let dble = !s1_chars.is_empty()
        && IS_DASH(s1_chars[0])
        && s1_chars.len() == 2
        && "abcdefghknoprstuvwxzLONGS".contains(s1_chars[1]);
    if tok() != STRING_LEX {
        if !s1.is_empty() && tok() != LEXERR && (!dble || n_testargs != 0) {
            // c:2557 — `[[ STRING ]]` re-interpreted as `[[ -n STRING ]]`.
            condlex();
            while COND_SEP() {
                condlex();
            }
            return par_cond_double("-n", &s1);
        }
        YYERROR!(ECUSED.get()); // c:2560 `YYERROR(ecused);`
    }
    condlex();
    if n_testargs == 2 && tok() != STRING_LEX && tokstr().is_some() && s1_chars.first().map_or(false, |c| IS_DASH(*c)) {
        // c:2563-2569 — something like "test -z" followed by a token. We'll
        // turn the token into a string (we've also checked it does have a
        // string representation).
        set_tok(STRING_LEX);
    } else {
        while COND_SEP() {
            condlex();
        }
    }
    if tok() == INANG_TOK || tok() == OUTANG_TOK {
        // c:2576 — `<` / `>` string compare.
        let xtok = tok();
        condlex();
        while COND_SEP() {
            condlex();
        }
        if tok() != STRING_LEX {
            YYERROR!(ECUSED.get()); // c:2577 `YYERROR(ecused);`
        }
        let s3 = tokstr().unwrap_or_default();
        condlex();
        while COND_SEP() {
            condlex();
        }
        let op = if xtok == INANG_TOK {
            COND_STRLT
        } else {
            COND_STRGTR
        };
        ecadd(WCB_COND(op as u32, 0));
        ecstr(&s1);
        ecstr(&s3);
        return 1;
    }
    if tok() != STRING_LEX {
        // c:2592 — only one operand seen → `[ -n s1 ]`.
        if tok() != LEXERR {
            if !dble || n_testargs != 0 {
                return par_cond_double("-n", &s1);
            }
            return par_cond_multi(&s1, &[]);
        }
        YYERROR!(ECUSED.get()); // c:2596 `YYERROR(ecused);`
    }
    let s2 = tokstr().unwrap_or_default();
    set_incond(incond() + 1);
    condlex();
    while COND_SEP() {
        condlex();
    }
    set_incond(incond() - 1);
    // c:Src/parse.c:2598-2600 — `if (!n_testargs) dble = (s2 &&
    // IS_DASH(*s2) && !s2[2]);` — RECOMPUTE dble based on s2 once
    // it's been read, so `[[ A -X B ]]` is treated as a 2-arg cond
    // `[ -X B ]` (par_cond_double) rather than a 3-arg triple. This
    // is what routes `[[ "" -a "x" ]]` to par_cond_double("", "-a")
    // → COND_ERROR "parse error: condition expected: ". Without
    // this, the original `dble` from s1 stayed false, the parser
    // grabbed s3 and built COND_MODI silently. parity bug #25.
    let s2_chars: Vec<char> = s2.chars().collect();
    let dble = if n_testargs == 0 {
        !s2_chars.is_empty() && IS_DASH(s2_chars[0]) && s2_chars.len() == 2
    } else {
        dble
    };
    if tok() == STRING_LEX && !dble {
        let s3 = tokstr().unwrap_or_default();
        condlex();
        while COND_SEP() {
            condlex();
        }
        if tok() == STRING_LEX {
            // c:2615 — n-ary `[ A op B C D ... ]`.
            let mut l: Vec<String> = vec![s2, s3];
            while tok() == STRING_LEX {
                l.push(tokstr().unwrap_or_default());
                condlex();
                while COND_SEP() {
                    condlex();
                }
            }
            return par_cond_multi(&s1, &l);
        }
        return par_cond_triple(&s1, &s2, &s3);
    }
    par_cond_double(&s1, &s2)
}

/// Port of `par_cond_double()` from `Src/parse.c:2626` — C signature `par_cond_double(char *a, char *b)`.
/// Emits wordcode for unary cond `[ -X b ]` or modular `[ -mod b ]`.
pub fn par_cond_double(a: &str, b: &str) -> i32 {
    // c:2628 — `if (!IS_DASH(a[0]) || !a[1])` — char-based, since
    // Dash is a single code point (`\u{e19b}`) and `a.len() < 2` on
    // BYTES would still pass for "-z" but fail for the marker form
    // `\u{e19b}z` (2 bytes). Walk by chars.
    let ac: Vec<char> = a.chars().collect();
    if ac.is_empty() || !IS_DASH(ac[0]) || ac.len() < 2 {
        // c:2629 `COND_ERROR("parse error: condition expected: %s", a)`.
        COND_ERROR!("parse error: condition expected: {}", a);
    }
    // c:2630 — `else if (!a[2] && strspn(a+1, "abcd...zhLONGS") == 1)`
    let unary_set = "abcdefgknoprstuvwxzhLONGS";
    if ac.len() == 2 && unary_set.contains(ac[1]) {
        // c:2631 — `ecadd(WCB_COND(a[1], 0));` uses the raw cond-op
        // letter byte as the opcode payload. Use the ASCII char's
        // code-point value directly — every letter in `unary_set`
        // fits in 7 bits.
        ecadd(WCB_COND(ac[1] as u32, 0));
        ecstr(b);
    } else {
        ecadd(WCB_COND(COND_MOD as u32, 1));
        ecstr(a);
        ecstr(b);
    }
    1
}

/// Port of `get_cond_num()` from `Src/parse.c:2643` — C signature `get_cond_num(char *tst)`. Returns
/// the index of `tst` in `{"nt","ot","ef","eq","ne","lt","gt","le","ge"}`
/// or `-1` if not a recognized binary cond operator.
pub fn get_cond_num(tst: &str) -> i32 {
    // c:2643
    const CONDSTRS: [&str; 9] = [
        "nt", "ot", "ef", "eq", "ne", "lt", "gt", "le", "ge", // c:2647
    ];
    for (i, &c) in CONDSTRS.iter().enumerate() {
        if c == tst {
            return i as i32; // c:2654
        }
    }
    -1 // c:2656
}

/// par_time's `static int inpartime` guard at C parse.c:1038
/// preventing infinite recursion on `time time foo`. The wordcode
/// path keeps this as a thread_local since C uses a function-level
/// `static int` (per-process; per-evaluator semantically matches).
thread_local! {
    static PARSER_INPARTIME: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}

thread_local! {
    /// !!! WARNING: RUST-ONLY HELPER !!!
    ///
    /// C's `par_cmd` has NO post-compound terminator check — a STRING after
    /// a compound simply ends the list (`par_list` c:670 sees a non-separator
    /// and stops), and the diagnostic, if any, comes from the `if (!r)` tail.
    /// zshrs added a strict check inside `par_cmd` (Bug #146) which is wrong
    /// inside an `if` CONDITION, where a word right after `{ … }` is the
    /// legal SHORTLOOPS body: `if { true } print true` (c:1476-1482,
    /// A01grammar.ztst:500). This counter suppresses the Rust-only check
    /// while a condition list is being parsed.
    static COND_LIST_DEPTH: std::cell::Cell<u32> = const { std::cell::Cell::new(0) };
}

/// Port of `par_cond_triple()` from `Src/parse.c:2659` — C decl `par_cond_triple(char *a, char *b, char *c)`.
/// Emits wordcode for the binary forms
/// `[ A op B ]` — `=` / `==` / `!=` / `<` / `>` / `=~` / `-X`.
///
/// C does `(b[0] == Equals || b[0] == '=')` etc., matching BOTH the
/// raw ASCII operator char AND its tokenized marker form per
/// `Src/zsh.h:159-194`:
///   Equals = `\u{e18d}`, Outang = `\u{e195}`, Inang  = `\u{e194}`,
///   Tilde  = `\u{e198}`, Bang   = `\u{e19c}`, Dash   = `\u{e19b}`.
/// Inside `[[ ... ]]` the lexer emits the marker bytes — comparing
/// against literal-only `b"=="` misses every cond op.
/// (The previous Rust port had the doc comment values wrong:
/// Outang=0x8e was actually Bar; Inang=0x91 was Inbrack;
/// Tilde=0x96 was OutangProc; Bang=0x8b was Outparmath. The code
/// itself uses the correct const names, so this was a docs-only fix.)
pub fn par_cond_triple(a: &str, b: &str, c: &str) -> i32 {
    // c:2659
    let bc: Vec<char> = b.chars().collect();
    let is_eq = |ch: char| ch == '=' || ch == Equals;
    let is_gt = |ch: char| ch == '>' || ch == Outang;
    let is_lt = |ch: char| ch == '<' || ch == Inang;
    let is_tilde = |ch: char| ch == '~' || ch == Tilde;
    let is_bang = |ch: char| ch == '!' || ch == Bang;

    // c:2663 — `(b[0] == Equals || b[0] == '=') && !b[1]` → `=` (single).
    if bc.len() == 1 && is_eq(bc[0]) {
        ecadd(WCB_COND(COND_STREQ as u32, 0));
        ecstr(a);
        ecstr(c);
        let np = ECNPATS.with(|cc| {
            let v = cc.get();
            cc.set(v + 1);
            v
        }) as u32;
        ecadd(np);
        return 1;
    }
    // c:2668-2673 — `(t0 = (b[0] == '>' || b[0] == Outang) || b[0] == '<' || b[0] == Inang) && !b[1]`
    // then `t0 ? COND_STRGTR : COND_STRLT`. The assignment binds only the first
    // parenthesised term, but the `||` chain over the whole expression makes it true for
    // '<' and Inang as well, so C always emits COND_STRGTR here: in `test`/`[`, `a < b` is
    // evaluated as `a > b` (the reference build does the same).
    if bc.len() == 1 && (is_gt(bc[0]) || is_lt(bc[0])) {
        let op = COND_STRGTR;
        ecadd(WCB_COND(op as u32, 0));
        ecstr(a);
        ecstr(c);
        let np = ECNPATS.with(|cc| {
            let v = cc.get();
            cc.set(v + 1);
            v
        }) as u32;
        ecadd(np);
        return 1;
    }
    // c:2674-2679 — `==` STRDEQ.
    if bc.len() == 2 && is_eq(bc[0]) && is_eq(bc[1]) {
        ecadd(WCB_COND(COND_STRDEQ as u32, 0));
        ecstr(a);
        ecstr(c);
        let np = ECNPATS.with(|cc| {
            let v = cc.get();
            cc.set(v + 1);
            v
        }) as u32;
        ecadd(np);
        return 1;
    }
    // c:2680-2684 — `!=` STRNEQ.
    if bc.len() == 2 && is_bang(bc[0]) && is_eq(bc[1]) {
        ecadd(WCB_COND(COND_STRNEQ as u32, 0));
        ecstr(a);
        ecstr(c);
        let np = ECNPATS.with(|cc| {
            let v = cc.get();
            cc.set(v + 1);
            v
        }) as u32;
        ecadd(np);
        return 1;
    }
    // c:2685-2691 — `=~` REGEX (no pattern slot — implicit COND_MODI).
    if bc.len() == 2 && is_eq(bc[0]) && is_tilde(bc[1]) {
        ecadd(WCB_COND(COND_REGEX as u32, 0));
        ecstr(a);
        ecstr(c);
        return 1;
    }
    // c:2692-2702 — `-OP` numeric-or-modular cond (e.g. `-eq`, `-nt`).
    if !bc.is_empty() && IS_DASH(bc[0]) {
        let rest: String = bc[1..].iter().collect();
        let t = get_cond_num(&rest);
        if t > -1 {
            ecadd(WCB_COND((t + COND_NT) as u32, 0));
            ecstr(a);
            ecstr(c);
            return 1;
        }
        ecadd(WCB_COND(COND_MODI as u32, 0));
        ecstr(b);
        ecstr(a);
        ecstr(c);
        return 1;
    }
    // c:2703-2707 — `-mod A B C` modular cond on `a`.
    let ac: Vec<char> = a.chars().collect();
    if !ac.is_empty() && IS_DASH(ac[0]) && ac.len() > 1 {
        ecadd(WCB_COND(COND_MOD as u32, 2));
        ecstr(a);
        ecstr(b);
        ecstr(c);
        return 1;
    }
    // c:2709
    COND_ERROR!("condition expected: {}", b);
}

/// Port of `par_cond_multi()` from `Src/parse.c:2716` — C signature `par_cond_multi(char *a, LinkList l)`.
/// Emits wordcode for `[ -OP A B C … ]` n-ary cond (alternation).
pub fn par_cond_multi(a: &str, l: &[String]) -> i32 {
    // c:2716 — `if (!IS_DASH(a[0]) || !a[1])`; same Dash/`-` dual
    // matching as par_cond_double, char-walked because Dash is a
    // single code point.
    let ac: Vec<char> = a.chars().collect();
    if ac.is_empty() || !IS_DASH(ac[0]) || ac.len() < 2 {
        // c:2719
        COND_ERROR!("condition expected: {}", a);
    }
    ecadd(WCB_COND(COND_MOD as u32, l.len() as u32));
    ecstr(a);
    for item in l {
        ecstr(item);
    }
    1
}

/// Emit a parser-level error. Direct port of zsh/Src/parse.c
/// 2733-2766 `yyerror`. C version fills a per-event error buffer
/// and sets errflag. zshrs pushes onto errors which the
/// caller drains via parse()'s Result return.
/// Port of `yyerror()` from `Src/parse.c:2733` — C decl `yyerror(int noerr)`.
///
/// Faithful C body (verbatim):
/// ```c
/// int t0; char *t;
/// if ((t = dupstring(zshlextext))) untokenize(t);
/// for (t0 = 0; t0 != 20; t0++)
///     if (!t || !t[t0] || t[t0] == '\n') break;
/// if (!(histdone & HISTFLAG_NOEXEC) && !(errflag & ERRFLAG_INT)) {
///     if (t0) {
///         t = metafy(t, t0, META_STATIC);
///         zwarn("parse error near `%s%s'", t, t0 == 20 ? "..." : "");
///     } else
///         zwarn("parse error");
/// }
/// if (!noerr && noerrs != 2)
///     errflag |= ERRFLAG_ERROR;
/// ```
///
/// `zshlextext` is the C lexer's current-token text (`Src/lex.c:170`
/// `char *tokstr`); zshrs's equivalent is `lex::tokstr()`. The "20"
/// is C's tail-truncation length for the error message.
pub fn yyerror(noerr: i32) {
    // c:2733
    // c:2738 — `if ((t = dupstring(zshlextext))) untokenize(t);`.
    // In C, `zshlextext` falls back to `tokstrings[tok]` (lex.c:1965)
    // for punctuation tokens that didn't capture a tokstr — that's
    // how "parse error near `)'" gets the `)` for OUTPAR. Mirror by
    // consulting `lex::tokstring(tok())` when the captured tokstr is
    // None.
    // `zshlextext` is published by exalias (lex.c:1965-2018) — tokstr
    // for word tokens, `tokstrings[tok]` for punctuation — and is NOT
    // refreshed at ENDINPUT, since zshlex stops calling exalias there
    // (c:276). Reading `tokstr` instead lost that last-token memory,
    // so a parse error at EOF printed a bare "parse error" where zsh
    // names the token it died on.
    let t_opt: Option<String> = crate::ported::lex::LEX_ZSHLEXTEXT
        .with_borrow(|t| t.clone())
        // C's `untokenize` maps EVERY token through `ztokens`, quote markers
        // included (Snull → `'`, Dnull → `"`); zshrs's `lex::untokenize` is
        // the value-stream variant that drops them, so `[[ x = "a\\b"( ]]`
        // reported `a\\b( ]]` where zsh reports `"a\\b"( ]]`.
        .map(|raw| crate::ported::lex::untokenize_ztokens(&raw));
    let t_bytes: Vec<u8> = t_opt
        .as_ref()
        .map(|s| s.as_bytes().to_vec())
        .unwrap_or_default();

    // c:2741-2743 — `for (t0 = 0; t0 != 20; t0++) if (!t || !t[t0]
    //   || t[t0] == '\n') break;`
    let mut t0: usize = 0;
    while t0 != 20 {
        // c:2741
        let stop =
            t_opt.is_none() || t0 >= t_bytes.len() || t_bytes[t0] == 0 || t_bytes[t0] == b'\n';
        if stop {
            break;
        }
        t0 += 1;
    }

    // c:2744 — `if (!(histdone & HISTFLAG_NOEXEC) && !(errflag &
    //   ERRFLAG_INT))`. The HISTFLAG_NOEXEC gate suppresses warnings
    //   from history-recall paths that aren't actually executing.
    let histdone_v = crate::ported::hist::histdone.load(Ordering::SeqCst);
    let hist_noexec = (histdone_v & crate::ported::zsh_h::HISTFLAG_NOEXEC as i32) != 0;
    let int_flagged = (errflag.load(Ordering::SeqCst) & crate::ported::zsh_h::ERRFLAG_INT) != 0;
    if !hist_noexec && !int_flagged {
        // c:2744
        if t0 != 0 {
            // c:2745
            // c:2746 — `t = metafy(t, t0, META_STATIC);` — re-metafy
            //   the truncated head so embedded Meta bytes display
            //   correctly. The Rust port already holds an untokenized
            //   string; use the byte slice [0..t0] directly.
            let head = std::str::from_utf8(&t_bytes[..t0]).unwrap_or_default();
            let suffix = if t0 == 20 { "..." } else { "" };
            crate::ported::utils::zwarn(&format!("parse error near `{}{}'", head, suffix));
        // c:2747
        } else {
            // c:2748
            crate::ported::utils::zwarn("parse error"); // c:2749
        }
    }
    // c:2751 — `if (!noerr && noerrs != 2) errflag |= ERRFLAG_ERROR;`.
    //   The `noerrs != 2` gate (suppress-only-fatal-errors) is preserved
    //   for parity with zerr/zwarn's matching check.
    let noerrs_v = *crate::ported::utils::noerrs_lock().lock().unwrap();
    if noerr == 0 && noerrs_v != 2 {
        // c:2751
        errflag.fetch_or(crate::ported::zsh_h::ERRFLAG_ERROR, Ordering::SeqCst);
        // c:2752
    }
}

// ============================================================
// Eprog runtime ops (parse.c:2767-2853)
//
// dupeprog / useeprog / freeeprog are zsh's reference-counting
// helpers for executable programs. zshrs's AST is owned by
// value (Rust ownership); cloning is a tree-deep copy via
// Clone, "use" is a no-op (the executor borrows the AST), and
// "free" is automatic on drop.
// ============================================================

/// Duplicate an Eprog. Direct port of zsh/Src/parse.c:2767
/// Port of `dupeprog()` from `Src/parse.c:2767` — C decl `dupeprog(Eprog p, int heap)`.
/// Deep-copies the wordcode array, string
/// table, and pattern-prog slots. `dummy_eprog` is returned
/// unchanged. `heap`-allocated copies get `nref = -1` (never
/// freed); real ones get `nref = 1`.
pub fn dupeprog(p: &eprog, heap: bool) -> eprog {
    // c:2774-2775 — `if (p == &dummy_eprog) return p;` — caller-
    // observable identity in C uses a pointer compare; Rust's
    // equivalent is "if it has the dummy's shape (single WCB_END
    // word and no strs), return a copy of the same shape".
    // c:2796-2797 — `for (i = r->npats; i--; pp++) *pp = dummy_patprog1;`
    // C uses `dummy_patprog1` as a placeholder; the Rust port has
    // `Vec<Patprog>` (Box<patprog>) — synthesize an equivalent zero-
    // initialized patprog for each slot (resolved later by
    // pattern.c::patcompile-on-first-use).
    let dummy_pat = || crate::ported::zsh_h::patprog {
        startoff: 0,
        size: 0,
        mustoff: 0,
        patmlen: 0,
        globflags: 0,
        globend: 0,
        flags: 0,
        patnpar: 0,
        patstartch: 0,
    };
    let r = eprog {
        // c:2778 — `flags = (heap ? EF_HEAP : EF_REAL) | (p->flags & EF_RUN);`
        flags: (if heap { EF_HEAP } else { EF_REAL }) | (p.flags & EF_RUN),
        len: p.len,
        npats: p.npats,
        // c:2787 — `nref = heap ? -1 : 1;`
        nref: if heap { -1 } else { 1 },
        prog: p.prog.clone(),
        strs: p.strs.clone(), // pool copied verbatim — provenance below
        pats: (0..p.npats).map(|_| Box::new(dummy_pat())).collect(),
        shf: None,
        dump: None,
        strs_metafied: p.strs_metafied, // pool copied verbatim — carry provenance
    };
    r
}

/// Port of `useeprog()` from `Src/parse.c:2813` — C signature `useeprog(Eprog p)`.
/// `if (p && p != &dummy_eprog && p->nref >= 0) p->nref++;` —
/// pin a real (non-heap, non-dummy) Eprog so it survives the
/// next `freeeprog`.
pub fn useeprog(p: &mut eprog) {
    // c:2815 — `if (p && p != &dummy_eprog && p->nref >= 0)`
    if p.nref >= 0 {
        p.nref += 1; // c:2816
    }
}

/// Port of `freeeprog()` from `Src/parse.c:2823` — C signature `freeeprog(Eprog p)`.
/// Refcount-decrement; when it hits zero, drops the pattern progs,
/// decrements the dump refcount if any, and releases the eprog.
/// `dummy_eprog` is never freed. Heap-eprogs (`nref < 0`) are
/// never freed either — they live as long as the heap arena.
pub fn freeeprog(p: &mut eprog) {
    // c:2829 — `if (p && p != &dummy_eprog) { ... }`
    if p.nref > 0 {
        p.nref -= 1; // c:2832
        if p.nref == 0 {
            // c:2833-2840 — drop pats, dump refcount, then the eprog.
            // Rust's Drop handles the per-field cleanup; we just
            // need to decrement the dump count first.
            if let Some(dump) = p.dump.take() {
                let dumped = (*dump).clone();
                decrdumpcount(&dumped); // c:2837
            }
            p.prog.clear();
            p.strs = None;
            p.pats.clear();
        }
    }
}

// =============================================================================
// Wordcode read helpers — used by text.rs's `gettext2` and exec dispatch
// to walk a compiled Eprog without re-running the parser. These are the
// only `Src/parse.c` functions ported so far in this file; the recursive-
// descent parser (par_event / par_list / par_cmd / par_*) follows
// below as free ported at module scope.
// =============================================================================

/// Port of `ecgetstr()` from `Src/parse.c:2855` — C signature `ecgetstr(Estate s, int dup, int *tokflag)`.
/// `s->pc` advances through the wordcode buffer; `s->strs` indexes the
/// string pool. Returns the interned string (or a 1-3-char literal
/// inlined directly into the wordcode word).
pub fn ecgetstr(s: &mut estate, dup: i32, tokflag: Option<&mut i32>) -> String {
    let prog = &s.prog.prog;
    if s.pc >= prog.len() {
        return String::new();
    }
    let c = prog[s.pc]; // c:2858 `wordcode c = *s->pc++;`
    s.pc += 1;
    if let Some(tf) = tokflag {
        *tf = i32::from((c & 1) != 0); // c:2880 `*tokflag = (c & 1);`
    }
    if c == 6 || c == 7 {
        // c:2861 `if (c == 6 || c == 7) r = "";`
        return String::new();
    }
    let r: String = if (c & 2) != 0 {
        // c:2862 — `else if (c & 2)`
        // c:2863-2868 — 3-byte inline string packed into the wordcode
        // word; followed by `buf[3] = '\0'; r = dupstring(buf);`.
        // C's `dupstring` uses `strlen(buf)` which TRUNCATES at the
        // first NUL byte — short strings of 1 or 2 chars get padded
        // with NULs and truncated cleanly. The previous Rust port
        // used `retain(|&x| x != 0)` which would silently SPLICE OUT
        // an interior NUL (e.g. `[a, 0, b]` → "ab"), diverging from
        // C's strlen-truncate (`[a, 0, b]` → "a"). Fix: truncate at
        // first NUL to match C exactly.
        let b0 = ((c >> 3) & 0xff) as u8;
        let b1 = ((c >> 11) & 0xff) as u8;
        let b2 = ((c >> 19) & 0xff) as u8;
        let v = [b0, b1, b2];
        let end = v.iter().position(|&x| x == 0).unwrap_or(v.len()); // c:2869 strlen(buf)
                                                                     // C reads raw bytes (token codes included) — widen via the
                                                                     // wordcode-pool bridge, never from_utf8_lossy (which mangles
                                                                     // raw token bytes from C-zsh-written .zwc dumps to U+FFFD).
        crate::zwc::wordcode_pool_str_unmeta(&v[..end], s.prog.strs_metafied)
    } else {
        // c:2877 `else r = s->strs + (c >> 2);`
        let off = (c >> 2) as usize + s.strs_offset;
        let strs_bytes = s.strs.as_deref().unwrap_or("").as_bytes();
        if off >= strs_bytes.len() {
            String::new()
        } else {
            let tail = &strs_bytes[off..];
            let end = tail.iter().position(|&b| b == 0).unwrap_or(tail.len());
            crate::zwc::wordcode_pool_str_unmeta(&tail[..end], s.prog.strs_metafied)
        }
    };
    // c:2891 `return ((dup == EC_DUP || (dup && (c & 1))) ? dupstring(r) : r);`
    // Rust owns the String already; `dup` flag has no observable effect.
    let _ = (dup, EC_DUP, EC_NODUP);
    r
}

// ============================================================
// Wordcode runtime getters (parse.c:2853-3060)
//
// Direct ports of the wordcode-read helpers (ecrawstr,
// ecgetstr, ecgetarr, ecgetredirs, ecgetlist, eccopyredirs).
// Read packed wordcode out of an Eprog at execution time.
// Used by exec_wordcode and the wordcode-walking dispatch in
// src/vm_helper.
// ============================================================

/// Port of `ecrawstr()` from `Src/parse.c:2891` — C decl `ecrawstr(Eprog p, Wordcode pc, int *tokflag)`.
/// Like `ecgetstr` but reads at the given pc
/// without advancing — caller steps `pc` separately.
pub fn ecrawstr(p: &eprog, pc: usize, tokflag: Option<&mut i32>) -> String {
    if pc >= p.prog.len() {
        return String::new();
    }
    let c = p.prog[pc]; // c:2894
    if let Some(tf) = tokflag {
        *tf = i32::from((c & 1) != 0); // c:2898/2906/2912
    }
    if c == 6 || c == 7 {
        // c:2897
        return String::new();
    }
    if (c & 2) != 0 {
        // c:2902-2906 — same 3-byte inline string as ecgetstr, then
        // `buf[3] = '\0'; return dupstring(buf);` — truncate at first
        // NUL via strlen (NOT splice out interior NULs).
        let b0 = ((c >> 3) & 0xff) as u8;
        let b1 = ((c >> 11) & 0xff) as u8;
        let b2 = ((c >> 19) & 0xff) as u8;
        let v = [b0, b1, b2];
        let end = v.iter().position(|&x| x == 0).unwrap_or(v.len()); // c:2906 strlen(buf)
                                                                     // Raw-byte widening — see ecgetstr (same C-convention bridge).
        crate::zwc::wordcode_pool_str_unmeta(&v[..end], p.strs_metafied)
    } else {
        // c:2911
        let off = (c >> 2) as usize;
        let strs_bytes = p.strs.as_deref().unwrap_or("").as_bytes();
        if off >= strs_bytes.len() {
            return String::new();
        }
        let tail = &strs_bytes[off..];
        let end = tail.iter().position(|&b| b == 0).unwrap_or(tail.len());
        crate::zwc::wordcode_pool_str_unmeta(&tail[..end], p.strs_metafied)
    }
}

/// Port of `ecgetarr()` from `Src/parse.c:2917` — C decl `ecgetarr(Estate s, int num, int dup, int *tokflag)`.
/// Reads `num` strings from wordcode at `s->pc`
/// and OR-folds each entry's token flag into `*tokflag`.
pub fn ecgetarr(s: &mut estate, num: usize, dup: i32, tokflag: Option<&mut i32>) -> Vec<String> {
    let mut ret: Vec<String> = Vec::with_capacity(num); // c:2922
    let mut tf: i32 = 0;
    for _ in 0..num {
        // c:2924 `while (num--)`
        let mut tmp = 0;
        ret.push(ecgetstr(s, dup, Some(&mut tmp))); // c:2925
        tf |= tmp; // c:2926
    }
    if let Some(out) = tokflag {
        // c:2929
        *out = tf;
    }
    ret
}

/// Port of `ecgetlist()` from `Src/parse.c:2937` — C decl `ecgetlist(Estate s, int num, int dup, int *tokflag)`.
/// Same shape as `ecgetarr` but C returns
/// `LinkList`; zshrs uses `Vec<String>` for both.
pub fn ecgetlist(s: &mut estate, num: usize, dup: i32, tokflag: Option<&mut i32>) -> Vec<String> {
    if num == 0 {
        // c:2949-2952
        if let Some(tf) = tokflag {
            *tf = 0;
        }
        return Vec::new();
    }
    ecgetarr(s, num, dup, tokflag)
}

/// Port of `ecgetredirs()` from `Src/parse.c:2959` — C signature `ecgetredirs(Estate s)`.
///
/// `strs` must be the same tail `ecgetstr` uses (`s->strs` / `estate.strs` from offset).
/// WARNING: param names don't match C — Rust=(prog, strs, pc) vs C=(s)
pub fn ecgetredirs(s: &mut estate) -> Vec<redir> {
    let mut ret: Vec<redir> = Vec::new(); // c:2959 `LinkList ret = newlinklist();`
    let prog_len = s.prog.prog.len();
    if s.pc >= prog_len {
        return ret;
    }
    let mut code = s.prog.prog[s.pc]; // c:2962 `wordcode code = *s->pc++;`
    s.pc += 1;

    loop {
        if wc_code(code) != WC_REDIR {
            // c:2988-2989 `s->pc--` then break from while
            s.pc = s.pc.saturating_sub(1);
            break;
        }

        let typ = WC_REDIR_TYPE(code); // c:2967 `r->type = WC_REDIR_TYPE(code);`
        if s.pc >= prog_len {
            break;
        }
        let fd1_w = s.prog.prog[s.pc]; // c:2968 `r->fd1 = *s->pc++;`
        s.pc += 1;

        let name = ecgetstr(s, EC_DUP, None); // c:2969 `r->name = ecgetstr(...)`

        let (flags, here_terminator, munged_here_terminator) = if WC_REDIR_FROM_HEREDOC(code) != 0 {
            // c:2970-2973
            let term = ecgetstr(s, EC_DUP, None);
            let munged = ecgetstr(s, EC_DUP, None);
            (REDIRF_FROM_HEREDOC, Some(term), Some(munged))
        } else {
            // c:2974-2977
            (0, None, None)
        };

        let varid = if WC_REDIR_VARID(code) != 0 {
            // c:2979-2980
            Some(ecgetstr(s, EC_DUP, None))
        } else {
            None // c:2981-2982
        };

        ret.push(redir {
            // c:2965-2982 fields + c:2984 `addlinknode`
            typ,
            flags,
            fd1: fd1_w as i32,
            fd2: 0,
            name: Some(name),
            varid,
            here_terminator,
            munged_here_terminator,
        });

        if s.pc >= prog_len {
            break;
        }
        code = s.prog.prog[s.pc]; // c:2986 `code = *s->pc++;`
        s.pc += 1;
    }

    ret // c:2990 `return ret`
}

/// Port of `eccopyredirs()` from `Src/parse.c:3003` — C signature `eccopyredirs(Estate s)`. Reads
/// the WC_REDIR run at `s->pc`, counts the wordcodes needed,
/// reserves space in `ecbuf` via `ecispace`, then re-walks `s->pc`
/// re-emitting each redir's wordcodes into the reserved slot —
/// finally calls `bld_eprog(0)` to package the result as an Eprog.
pub fn eccopyredirs(s: &mut estate) -> Option<eprog> {
    let prog_len = s.prog.prog.len();
    if s.pc >= prog_len {
        return None;
    }
    // c:3007-3009 — `if (wc_code(*pc) != WC_REDIR) return NULL;`
    let first_code = s.prog.prog[s.pc];
    if wc_code(first_code) != WC_REDIR {
        return None;
    }
    // c:3011 — `init_parse();`
    init_parse();

    // c:3013-3027 — count wordcodes the redir run will need.
    // Each WC_REDIR contributes `code + fd1 + name` = 3, plus
    // `+2` if WC_REDIR_FROM_HEREDOC (terminator + munged), plus
    // `+1` if WC_REDIR_VARID.
    let mut probe = s.pc;
    let mut ncodes = 0usize;
    loop {
        if probe >= prog_len {
            break;
        }
        let code = s.prog.prog[probe];
        if wc_code(code) != WC_REDIR {
            break;
        }
        let mut ncode = if WC_REDIR_FROM_HEREDOC(code) != 0 {
            5
        } else {
            3
        };
        if WC_REDIR_VARID(code) != 0 {
            ncode += 1;
        }
        probe += ncode;
        ncodes += ncode;
    }

    // c:3028-3029 — `r = ecused; ecispace(r, ncodes);`
    let r0 = ECUSED.get() as usize;
    ecispace(r0, ncodes);

    // c:3031-3053 — re-walk `s->pc` and write into ecbuf[r..].
    let mut r = r0;
    loop {
        if s.pc >= prog_len {
            break;
        }
        let code = s.prog.prog[s.pc];
        if wc_code(code) != WC_REDIR {
            break;
        }
        s.pc += 1;
        // c:3036 — `ecbuf[r++] = code;`
        ECBUF.with_borrow_mut(|buf| {
            if r >= buf.len() {
                buf.resize(r + 1, 0);
            }
            buf[r] = code;
        });
        r += 1;
        // c:3038 — `ecbuf[r++] = *s->pc++;` (the fd1 word)
        let fd1 = s.prog.prog[s.pc];
        s.pc += 1;
        ECBUF.with_borrow_mut(|buf| {
            if r >= buf.len() {
                buf.resize(r + 1, 0);
            }
            buf[r] = fd1;
        });
        r += 1;
        // c:3041 — `ecbuf[r++] = ecstrcode(ecgetstr(s, EC_NODUP, NULL));`
        let name = ecgetstr(s, EC_NODUP, None);
        let nc = ecstrcode(&name);
        ECBUF.with_borrow_mut(|buf| {
            if r >= buf.len() {
                buf.resize(r + 1, 0);
            }
            buf[r] = nc;
        });
        r += 1;
        // c:3042-3047 — heredoc terminators.
        if WC_REDIR_FROM_HEREDOC(code) != 0 {
            let term = ecgetstr(s, EC_NODUP, None);
            let tc = ecstrcode(&term);
            ECBUF.with_borrow_mut(|buf| {
                if r >= buf.len() {
                    buf.resize(r + 1, 0);
                }
                buf[r] = tc;
            });
            r += 1;
            let munged = ecgetstr(s, EC_NODUP, None);
            let mc = ecstrcode(&munged);
            ECBUF.with_borrow_mut(|buf| {
                if r >= buf.len() {
                    buf.resize(r + 1, 0);
                }
                buf[r] = mc;
            });
            r += 1;
        }
        // c:3048-3049 — varid.
        if WC_REDIR_VARID(code) != 0 {
            let varid = ecgetstr(s, EC_NODUP, None);
            let vc = ecstrcode(&varid);
            ECBUF.with_borrow_mut(|buf| {
                if r >= buf.len() {
                    buf.resize(r + 1, 0);
                }
                buf[r] = vc;
            });
            r += 1;
        }
    }

    // c:3056 — `return bld_eprog(0);` — `bld_eprog` appends the
    // WC_END marker and packages ECBUF/ECSTRS into an Eprog.
    Some(bld_eprog(false))
}

/// Port of `init_eprog()` from `Src/parse.c:3069` — C signature `init_eprog(void)`. Sets up
/// `dummy_eprog_code = WCB_END(); dummy_eprog.len = sizeof(wordcode);
/// dummy_eprog.prog = &dummy_eprog_code; dummy_eprog.strs = NULL;`.
/// Called once at shell startup (init_main → init_misc → init_eprog).
pub fn init_eprog() {
    let mut d = DUMMY_EPROG.lock().unwrap();
    d.prog = vec![WCB_END()]; // c:3071/3073
    d.len = size_of::<wordcode>() as i32; // c:3072
    d.strs = None; // c:3074
    d.flags = 0;
    d.npats = 0;
    d.nref = 0;
}

// =====================================================================
// `bin_zcompile` and wordcode-dump helpers — port of `Src/parse.c:3104+`.
//
// The wordcode dump format (`.zwc`) is a serialized parse tree zsh can
// `mmap()` and dispatch from without re-parsing on every shell start.
// File layout (one struct = `FD_PRELEN` `u32`s):
//   - `pre[0]` = magic word (FD_MAGIC native byte-order, FD_OMAGIC
//     opposite byte-order).
//   - `pre[1]` = packed `{flags(8) | other_offset(24)}` byte field.
//   - `pre[2..12]` = `ZSH_VERSION` C-string padded to 40 bytes.
//   - `pre[12]` = `fdheaderlen` (total prelude+header word count).
//   - Then a sequence of `struct fdhead` records, one per function,
//     each followed by its NUL-terminated name (padded to 4-byte).
//   - Then the wordcode bytes for every function back-to-back.
//
// On a little-endian host writing a dump twice: first `FD_MAGIC` for
// native readers, then re-walks the body byte-swapped and emits a
// second `FD_OMAGIC` copy so big-endian readers can mmap it too.
// =====================================================================

// File-format constants — port of `Src/parse.c:3104-3150`.

/// `#define FD_EXT ".zwc"` from `Src/parse.c:3104`.
pub const FD_EXT: &str = ".zwc";

/// `#define FD_MINMAP 4096` from `Src/parse.c:3105`. mmap threshold
/// — `-M` mode only kicks in when the wordcode body is at least
/// this many bytes (otherwise read(2) is preferred).
pub const FD_MINMAP: usize = 4096;

/// `#define FD_PRELEN 12` from `Src/parse.c:3107`. File-header
/// length in u32 words: magic + packed-flags-byte + 10 version words.
pub const FD_PRELEN: usize = 12;

/// `#define FD_MAGIC 0x04050607` from `Src/parse.c:3108`. Sentinel
/// for native-byte-order dumps.
pub const FD_MAGIC: u32 = 0x04050607;

/// `#define FD_OMAGIC 0x07060504` from `Src/parse.c:3109`. Sentinel
/// for opposite-byte-order dumps (byte-swapped FD_MAGIC).
pub const FD_OMAGIC: u32 = 0x07060504;

/// `#define FDF_MAP 1` from `Src/parse.c:3111`. Bit set when the
/// dump should be `mmap()`-ed (`-M` flag) vs read normally (`-R`).
pub const FDF_MAP: u32 = 1;

/// `#define FDF_OTHER 2` from `Src/parse.c:3112`. Bit indicating
/// this dump has an opposite-byte-order copy at `fdother(f)`.
pub const FDF_OTHER: u32 = 2;

/// Port of `struct fdhead` from `Src/parse.c:3116`. One per function
/// inside a wordcode dump. All fields are `wordcode` (u32).
#[allow(non_camel_case_types)]
#[derive(Debug, Clone, Copy)]
pub struct fdhead {
    /// Offset (in u32 words) to the start of this function's
    /// wordcode body inside the dump.
    pub start: u32, // c:3117
    /// Wordcode-byte length of the body (excludes pattern-prog slots).
    pub len: u32, // c:3118
    /// Number of compiled patterns the body references.
    pub npats: u32, // c:3119
    /// Offset of the string table inside `prog->prog`.
    pub strs: u32, // c:3120
    /// Header-record length in u32 words (record + name).
    pub hlen: u32, // c:3121
    /// Packed `{ kshload_bits(2) | name_tail_offset(30) }` field.
    pub flags: u32, // c:3122
}

/// `#define FDHF_KSHLOAD 1` from `Src/parse.c:3149`. Function-header
/// flag word — `-k` ksh-style autoload marker.
pub const FDHF_KSHLOAD: u32 = 1;

/// `#define FDHF_ZSHLOAD 2` from `Src/parse.c:3150`. `-z` zsh-style
/// autoload marker.
pub const FDHF_ZSHLOAD: u32 = 2;

/// Port of `struct wcfunc` from `Src/parse.c:3158`. Build-time
/// per-function aggregate before write_dump emits it: the function
/// (or source-file) name, the compiled `Eprog` from `parse_string`,
/// and the FDHF_* autoload-style flag word.
#[allow(non_camel_case_types)]
#[derive(Debug, Clone)]
pub struct wcfunc {
    pub name: String, // c:3159
    /// Compiled program (`Eprog prog` c:3160) — wordcode + strs +
    /// npats as built by `bld_eprog`.
    pub prog: eprog, // c:3160
    pub flags: u32,   // c:3161
}

/// Port of `dump_find_func()` from `Src/parse.c:3167` — C decl `dump_find_func(Wordcode h, char *name)`.
/// Walks the header table inside a loaded
/// dump for a function with the given basename; returns the
/// matching `fdhead` record (C returns the `FDHead` pointer).
pub fn dump_find_func(h: &[u32], name: &str) -> Option<fdhead> {
    // c:3167
    let header_words = fdheaderlen(h) as usize;
    let end = header_words; // walking u32 offsets, end-exclusive
    // c:3152 — `fdname(n)` is a `char *` INTO the header words, so C compares
    // in place. The same view here: the words were read in host byte order
    // (load_dump_header, c:3268), exactly the bytes C's pointer walks.
    // SAFETY: a byte view of the u32 header words; u32 has no padding and
    // every bit pattern is a valid u8.
    let header_bytes = unsafe { std::slice::from_raw_parts(h.as_ptr() as *const u8, h.len() * 4) };
    let want = name.as_bytes();
    let mut cur = firstfdhead_offset();
    while cur < end {
        if let Some(fh) = read_fdhead(h, cur) {
            // c:3172 — `if (!strcmp(name, fdname(n) + fdhtail(n)))`: compinit's
            // `autoload -rUz` walks every entry of every `$fpath` digest, so
            // this is one slice prefix test plus the NUL strcmp stops at, not a
            // per-byte lookup through each u32 word. A name running to the end
            // of the header counts as terminated, as the per-byte reader did.
            let name_start = (cur + FDHEAD_WORDS) * 4 + fdhtail(&fh) as usize;
            let entry = header_bytes.get(name_start..).unwrap_or(&[]);
            let same = entry.starts_with(want) && entry.get(want.len()).map_or(true, |&b| b == 0);
            if same {
                return Some(fh); // c:3173 `return n;`
            }
            cur = nextfdhead_offset(h, cur);
        } else {
            break;
        }
    }
    None // c:3175
}

/// Port of `bin_zcompile()` from `Src/parse.c:3180` — C decl `bin_zcompile(char *nam, char **args, Options ops, UNUSED(int func))`.
/// Validates the option set, then dispatches
/// to one of: `-t` (test/list), `-c`/`-a` (dump current functions),
/// or the default (compile source files to `.zwc`).
pub fn bin_zcompile(
    nam: &str, // c:3180
    args: &[String],
    ops: &crate::ported::zsh_h::options,
    _func: i32,
) -> i32 {
    // c:3185-3192 — illegal-combination guard.
    if (OPT_ISSET(ops, b'k') && OPT_ISSET(ops, b'z'))
        || (OPT_ISSET(ops, b'R') && OPT_ISSET(ops, b'M'))
        || (OPT_ISSET(ops, b'c')
            && (OPT_ISSET(ops, b'U') || OPT_ISSET(ops, b'k') || OPT_ISSET(ops, b'z')))
        || (!(OPT_ISSET(ops, b'c') || OPT_ISSET(ops, b'a')) && OPT_ISSET(ops, b'm'))
    {
        zwarnnam(nam, "invalid combination of options"); // c:3192
        return 1;
    }

    // c:3194 — `-c`/`-a` + KSHAUTOLOAD warning.
    if (OPT_ISSET(ops, b'c') || OPT_ISSET(ops, b'a')) && isset(crate::ported::zsh_h::KSHAUTOLOAD) {
        zwarnnam(nam, "functions will use zsh style autoloading"); // c:3195
    }

    // c:3196-3197 — flag word from `-k` / `-z`.
    let flags: u32 = if OPT_ISSET(ops, b'k') {
        FDHF_KSHLOAD
    } else if OPT_ISSET(ops, b'z') {
        FDHF_ZSHLOAD
    } else {
        0
    };

    // c:3199 — `-t` test/list mode.
    if OPT_ISSET(ops, b't') {
        // c:3199
        if args.is_empty() {
            zwarnnam(nam, "too few arguments"); // c:3202
            return 1;
        }
        let dump_name = if args[0].ends_with(FD_EXT) {
            args[0].clone()
        } else {
            format!("{}{}", args[0], FD_EXT)
        };
        let f = match load_dump_header(nam, &dump_name, 1) {
            // c:3206
            Some(buf) => buf,
            None => return 1,
        };
        // c:3209 — per-function check.
        if args.len() > 1 {
            for name in &args[1..] {
                // c:3210
                if dump_find_func(&f, name).is_none() {
                    // c:3212
                    return 1;
                }
            }
            return 0;
        }
        // c:3215-3221 — listing arm. Walk every fdhead, print
        // each function's full name. C uses `fdname(h)` which
        // includes the path prefix; matches our `fdname()` impl.
        let mapped = if (fdflags(&f) & FDF_MAP) != 0 {
            "mapped"
        } else {
            "read"
        };
        println!("zwc file ({}) for zsh-{}", mapped, fdversion(&f));
        let header_words = fdheaderlen(&f) as usize;
        let mut cur = firstfdhead_offset();
        while cur < header_words {
            if read_fdhead(&f, cur).is_none() {
                break;
            }
            println!("{}", fdname(&f, cur));
            cur = nextfdhead_offset(&f, cur);
        }
        return 0;
    }

    if args.is_empty() {
        zwarnnam(nam, "too few arguments"); // c:3226
        return 1;
    }

    // c:3228 — map mode discriminant.
    let map: i32 = if OPT_ISSET(ops, b'M') {
        2
    } else if OPT_ISSET(ops, b'R') {
        0
    } else {
        1
    };

    // c:3230-3236 — single-file default-mode short path.
    if args.len() == 1 && !(OPT_ISSET(ops, b'c') || OPT_ISSET(ops, b'a')) {
        let dump = format!("{}{}", args[0], FD_EXT);
        return build_dump(nam, &dump, args, OPT_ISSET(ops, b'U') as i32, map, flags);
    }

    // c:3239-3247 — multi-file or `-c`/`-a` mode.
    let dump = if args[0].ends_with(FD_EXT) {
        args[0].clone()
    } else {
        format!("{}{}", args[0], FD_EXT)
    };
    let rest = &args[1..];
    if OPT_ISSET(ops, b'c') || OPT_ISSET(ops, b'a') {
        let what =
            (if OPT_ISSET(ops, b'c') { 1 } else { 0 }) | (if OPT_ISSET(ops, b'a') { 2 } else { 0 });
        build_cur_dump(nam, &dump, rest, OPT_ISSET(ops, b'm') as i32, map, what)
    } else {
        build_dump(nam, &dump, rest, OPT_ISSET(ops, b'U') as i32, map, flags)
    }
}

/// Port of `load_dump_header()` from `Src/parse.c:3258` — C decl `load_dump_header(char *nam, char *name, int err)`.
/// Opens the file, reads + validates the magic
/// and version, then slurps the full header table into memory.
/// Returns the header u32-array on success or None on any failure
/// (emitting C-shaped warnings when `err != 0`).
pub fn load_dump_header(nam: &str, name: &str, err: i32) -> Option<Vec<u32>> {
    // !!! WARNING: RUST-ONLY HELPER !!!
    //
    // C's `nam` is a `char *`, and `check_dump_file` passes it as NULL:
    // c:Src/parse.c:3870 — `load_dump_header(NULL, file, 0)`. In C
    // `zwarnnam(NULL, …)` is NOT silent: it reaches `zwarning(NULL, …)` and
    // takes the else branch there, printing the bare `scriptname:` prefix —
    // exactly what `zwarn` does. The Rust signature is `&str`, so NULL is
    // encoded as `""`, and `zwarnnam("")` instead takes `zwarning(Some(""))`'s
    // CMD branch (utils.rs) — prefix `:` then the empty cmd then another `:` —
    // emitting a SECOND colon:
    //     zsh    zsh:1: invalid zwc file: <path>    /  _zz01:2: …
    //     zshrs  zshrs::1: invalid zwc file: <path> /  _zz01::2: …
    //
    // Route the empty name to `zwarn`, which is the same output C's NULL
    // branch produces. Same trap, same C citations, as the note in
    // `src/ported/jobs.rs`.
    let warn_nam = |msg: &str| {
        if nam.is_empty() {
            crate::ported::utils::zwarn(msg)
        } else {
            zwarnnam(nam, msg)
        }
    };
    // c:3258

    let mut f = match File::open(name) {
        // c:3263
        Ok(h) => h,
        Err(_) => {
            if err != 0 {
                warn_nam(&format!("can't open zwc file: {}", name)); // c:3265
            }
            return None;
        }
    };

    // c:3261 `wordcode buf[FD_PRELEN + 1];` + c:3268 `read(fd, buf, (FD_PRELEN + 1) *
    // sizeof(wordcode))` — the words are read straight into the wordcode
    // buffer, in host byte order; `fdmagic` below is what detects a file
    // written with the other order (c:3270, c:3285-3301).
    let mut buf: Vec<u32> = vec![0u32; FD_PRELEN + 1];
    // SAFETY: a byte view of the u32 buffer, as C's `read(fd, buf, n *
    // sizeof(wordcode))`; u32 has no padding and every bit pattern is valid.
    let buf_bytes =
        unsafe { std::slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut u8, buf.len() * 4) };
    if f.read_exact(buf_bytes).is_err() {
        if err != 0 {
            warn_nam(&format!("invalid zwc file: {}", name)); // c:3277
        }
        return None;
    }

    // c:3270 — magic + version check against `ZSH_VERSION` (C global;
    // zshrs mirrors it in `patchlevel::ZSH_VERSION`).
    let magic_ok = fdmagic(&buf) == FD_MAGIC || fdmagic(&buf) == FD_OMAGIC;
    let v_ok = fdversion(&buf) == crate::ported::patchlevel::ZSH_VERSION;
    if !magic_ok {
        if err != 0 {
            warn_nam(&format!("invalid zwc file: {}", name)); // c:3277
        }
        return None;
    }
    if !v_ok {
        if err != 0 {
            warn_nam(
                &format!(
                    "zwc file has wrong version (zsh-{}): {}", // c:3274
                    fdversion(&buf),
                    name
                ),
            );
        }
        return None;
    }

    // c:3285 — if magic matches host byte order, head len is `pre[FD_PRELEN]`.
    // Else seek to `fdother(buf)` and re-read.
    if fdmagic(&buf) != FD_MAGIC {
        let other = fdother(&buf) as u64; // c:3290
        // c:3292-3294 — re-read the other copy's prefix into the same buffer.
        // SAFETY: byte view of the u32 buffer, as above.
        let buf_bytes =
            unsafe { std::slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut u8, buf.len() * 4) };
        if f.seek(SeekFrom::Start(other)).is_err() || f.read_exact(buf_bytes).is_err() {
            warn_nam(&format!("invalid zwc file: {}", name)); // c:3295
            return None;
        }
    }

    let total_words = fdheaderlen(&buf) as usize; // c:3286/3299
    if total_words < FD_PRELEN + 1 {
        warn_nam(&format!("invalid zwc file: {}", name));
        return None;
    }

    // c:3287/3300 `head = zhalloc(len)`, c:3302 `memcpy(head, buf, (FD_PRELEN +
    // 1) * sizeof(wordcode))`, c:3304-3305 `read(fd, head + (FD_PRELEN + 1),
    // len)` — the rest of the header is read straight into the words after
    // the prefix, one read, no per-word conversion. Converting byte chunks
    // one word at a time was most of `compinit`'s cost here: every
    // `autoload -r` lookup re-reads each digest header on $fpath, which C
    // does too (check_dump_file maps a digest only for a non-test lookup).
    let mut head: Vec<u32> = vec![0u32; total_words];
    head[..FD_PRELEN + 1].copy_from_slice(&buf); // c:3302
    let rest = &mut head[FD_PRELEN + 1..];
    if !rest.is_empty() {
        // SAFETY: byte view of the u32 words, as above.
        let rest_bytes =
            unsafe { std::slice::from_raw_parts_mut(rest.as_mut_ptr() as *mut u8, rest.len() * 4) };
        if f.read_exact(rest_bytes).is_err() {
            warn_nam(&format!("invalid zwc file: {}", name)); // c:3307
            return None;
        }
    }
    Some(head) // c:3311
}

/// Port of `fdswap()` from `Src/parse.c:3318` — C signature `fdswap(Wordcode p, int n)`.
/// Byte-swap each u32 in `p[..n]` in place. Used when writing the
/// opposite-byte-order copy of a wordcode dump.
pub fn fdswap(p: &mut [u32]) {
    // c:3318
    for w in p.iter_mut() {
        *w = w.swap_bytes();
    }
}

/// Port of `write_dump()` from `Src/parse.c:3334` — C decl `write_dump(int dfd, LinkList progs, int map, int hlen, int tlen)`.
/// Writes the prelude + header records +
/// body wordcode bytes to the dump file descriptor.
///
/// Two passes: first native-byte-order (`FD_MAGIC`), then opposite-
/// byte-order (`FD_OMAGIC`) so big-endian readers can mmap the
/// same file. Bodies are byte-swapped via `fdswap` on the second pass.
pub fn write_dump(
    dfd: &mut File, // c:3334
    progs: &[wcfunc],
    mut map: i32,
    hlen: i32,
    tlen: i32,
) -> std::io::Result<()> {
    // c:3345-3346 — `if (map == 1) map = (tlen >= FD_MINMAP);`
    if map == 1 {
        map = ((tlen as usize) >= FD_MINMAP) as i32;
    }

    // C `sizeof(Patprog)` — pointer size (see bld_eprog len arithmetic).
    let patprog_size = size_of::<*const u8>() as i32;

    let mut other = 0u32; // c:3338
    let ohlen = hlen;

    loop {
        // c:3349 — `for (ohlen = hlen; ; hlen = ohlen)`.
        let mut cur_hlen = ohlen;
        // c:3348 — `memset(pre, 0, sizeof(wordcode) * FD_PRELEN);`
        let mut pre = vec![0u32; FD_PRELEN];
        pre[0] = if other != 0 { FD_OMAGIC } else { FD_MAGIC }; // c:3350
        let flags = (if map != 0 { FDF_MAP } else { 0 }) | other;
        fdsetflags(&mut pre, flags as u8); // c:3351
        fdsetother(&mut pre, tlen as u32); // c:3352
                                           // c:3353 — copy ZSH_VERSION C-string into pre[2..].
        let ver = crate::ported::patchlevel::ZSH_VERSION.as_bytes();
        for (i, &b) in ver.iter().enumerate() {
            let word = 2 + i / 4;
            let shift = (i % 4) * 8;
            pre[word] |= (b as u32) << shift;
        }
        // c:3354 — write prelude.
        for w in &pre {
            dfd.write_all(&w.to_le_bytes())?;
        }
        // c:3356 — per-fn header records.
        for wcf in progs {
            let n = &wcf.name;
            let prog = &wcf.prog;
            // c:3362-3363 — body length in bytes excluding the
            // pattern-prog slots: `prog->len - (prog->npats *
            // sizeof(Patprog))`.
            let len_bytes = prog.len - prog.npats * patprog_size;
            let mut head = fdhead {
                start: cur_hlen as u32,   // c:3360
                len: len_bytes as u32,    // c:3363
                npats: prog.npats as u32, // c:3364
                // c:3365 — `head.strs = prog->strs - ((char *) prog->prog);`
                // In bld_eprog's layout strs sits right after the code
                // words, so the byte offset is ecused * 4.
                strs: (prog.prog.len() * 4) as u32, // c:3365
                hlen: ((FDHEAD_WORDS as u32) + ((n.len() as u32 + 4) / 4)), // c:3366
                flags: 0,
            };
            // c:3361 — `hlen += (prog->len - npats*sizeof(Patprog) +
            //                    sizeof(wordcode) - 1) / sizeof(wordcode);`
            cur_hlen += (len_bytes + 3) / 4;
            // c:3368-3371 — name tail offset from path basename.
            let tail = n.rfind('/').map(|p| p + 1).unwrap_or(0);
            head.flags = fdhbldflags(wcf.flags, tail as u32); // c:3372
                                                              // c:3373 — opposite-byte-order swap on second pass.
            let mut head_words: Vec<u32> = vec![
                head.start, head.len, head.npats, head.strs, head.hlen, head.flags,
            ];
            if other != 0 {
                fdswap(&mut head_words);
            }
            for w in &head_words {
                dfd.write_all(&w.to_le_bytes())?;
            }
            // c:3376-3379 — write the name + NUL, then pad to a word
            // boundary with the leading bytes of `head` (C: `write_loop
            // (dfd, (char *)&head, sizeof(wordcode) - tmp);`).
            dfd.write_all(n.as_bytes())?;
            dfd.write_all(&[0u8])?;
            let tmp = (n.len() + 1) & 3;
            if tmp != 0 {
                let head_bytes = head_words[0].to_le_bytes();
                dfd.write_all(&head_bytes[..4 - tmp])?;
            }
        }
        // c:3381-3388 — per-fn bodies: code words then the strs region,
        // padded to a word boundary. `tmp = (prog->len - npats*
        // sizeof(Patprog) + sizeof(wordcode) - 1) / sizeof(wordcode);
        // write_loop(dfd, (char *)prog->prog, tmp * sizeof(wordcode));`
        for wcf in progs {
            let prog = &wcf.prog;
            let len_bytes = (prog.len - prog.npats * patprog_size) as usize;
            let tmp = (len_bytes + 3) / 4;
            // c:3386-3387 — on the other pass only the code words are
            // swapped (`fdswap(prog->prog, ((Wordcode) prog->strs) -
            // prog->prog)`); the strs chars are byte-order neutral.
            let mut body_bytes: Vec<u8> = Vec::with_capacity(tmp * 4);
            for &w in &prog.prog {
                let w = if other != 0 { w.swap_bytes() } else { w };
                body_bytes.extend_from_slice(&w.to_le_bytes());
            }
            if let Some(s) = &prog.strs {
                body_bytes.extend_from_slice(s.as_bytes());
            }
            // C reads up to 3 bytes of heap slop past strs; emit NULs
            // (readers never look past head.len so the value is free).
            body_bytes.resize(tmp * 4, 0);
            dfd.write_all(&body_bytes)?;
        }
        if other != 0 {
            // c:3389
            break;
        }
        other = FDF_OTHER; // c:3391
    }
    Ok(())
}

/// Port of `build_dump()` from `Src/parse.c:3397` — C signature
/// `build_dump(char *nam, char *dump, char **files, int ali, int map, int flags)`.
/// Source-file → wordcode dump compiler:
/// parses each source file via `parse_string` and serializes the
/// resulting `Eprog`s through `write_dump` into `<dump>.zwc`.
pub fn build_dump(
    nam: &str, // c:3397
    dump: &str,
    files: &[String],
    ali: i32,
    map: i32,
    flags: u32,
) -> i32 {
    use crate::ported::utils::{errflag, ERRFLAG_ERROR};
    use std::os::unix::fs::OpenOptionsExt;
    use std::sync::atomic::Ordering;

    // c:3403-3404 — append FD_EXT unless already suffixed.
    let dump: String = if dump.ends_with(FD_EXT) {
        dump.to_string()
    } else {
        format!("{}{}", dump, FD_EXT)
    };

    // c:3406 — `unlink(dump);`
    let _ = fs::remove_file(&dump);
    // c:3407-3410 — `open(dump, O_WRONLY|O_CREAT, 0444)`.
    let mut dfd = match fs::OpenOptions::new()
        .write(true)
        .create(true)
        .mode(0o444)
        .open(&dump)
    {
        Ok(f) => f,
        Err(_) => {
            zwarnnam(nam, &format!("can't write zwc file: {}", dump)); // c:3408
            return 1;
        }
    };

    let patprog_size = size_of::<*const u8>() as i32; // C sizeof(Patprog)
    let ona = crate::ported::lex::noaliases(); // c:3398 `ona = noaliases`
    crate::ported::lex::set_noaliases(ali != 0); // c:3412 `noaliases = ali;`

    let mut progs: Vec<wcfunc> = Vec::new(); // c:3411
    let mut flags = flags;
    let mut hlen = FD_PRELEN as i32; // c:3414
    let mut tlen: i32 = 0;

    for fname in files {
        // c:3418-3425 — `-k` / `-z` pseudo-args flip the autoload style.
        if check_cond(fname, "k") {
            flags = (flags & !(FDHF_KSHLOAD | FDHF_ZSHLOAD)) | FDHF_KSHLOAD; // c:3419
            continue;
        } else if check_cond(fname, "z") {
            flags = (flags & !(FDHF_KSHLOAD | FDHF_ZSHLOAD)) | FDHF_ZSHLOAD; // c:3422
            continue;
        }
        // c:3426-3437 — open + fstat + S_ISREG + read the whole file.
        let fnam = crate::ported::utils::unmeta(fname); // c:3426
        let is_reg = fs::metadata(&fnam).map(|m| m.is_file()).unwrap_or(false);
        let bytes = if is_reg { fs::read(&fnam).ok() } else { None };
        let bytes = match bytes {
            Some(b) => b,
            None => {
                zwarnnam(nam, &format!("can't open file: {}", fname)); // c:3432
                crate::ported::lex::set_noaliases(ona); // c:3433
                let _ = fs::remove_file(&dump); // c:3434
                return 1;
            }
        };
        // c:3450 — `file = metafy(file, flen, META_REALLOC);` — C hands
        // the metafied bytes straight to `parse_string`, because C's lexer
        // eats metafied bytes. The Rust lexer eats char-form text, and
        // `utils::metafy` builds a BYTE-form buffer that no `String` can
        // hold, so it fell back to `from_utf8_lossy` and stamped U+FFFD
        // into the dump: `zcompile` of `print -r -- a\u{2014}b` wrote the
        // pool bytes `61 e2 80 83 a3 ef bf bd 62` where zsh writes
        // `61 e2 80 83 b4 62`, and sourcing that dump printed the
        // replacement character in BOTH shells. C's byte-level metafy is
        // applied where it belongs — `ecstrcode` (c:436, parse.rs:346)
        // converts char-form to C-byte form as the pool is written — so
        // what the lexer needs here is char-form text.
        let file = crate::script_bytes::decode_script_bytes(&bytes);

        // c:3452-3460 — parse; any error aborts the whole dump.
        let prog = crate::ported::exec::parse_string(&file, 1);
        let errored = (errflag.load(Ordering::Relaxed) & ERRFLAG_ERROR) != 0;
        let prog = match prog {
            Some(p) if !errored => p,
            _ => {
                errflag.fetch_and(!ERRFLAG_ERROR, Ordering::Relaxed); // c:3453
                zwarnnam(nam, &format!("can't read file: {}", fname)); // c:3456
                crate::ported::lex::set_noaliases(ona); // c:3457
                let _ = fs::remove_file(&dump); // c:3458
                return 1;
            }
        };

        // c:3467-3472 — accumulate header + body length budgets.
        let flen = (fname.len() as i32 + 4) / 4; // c:3469
        hlen += (FDHEAD_WORDS as i32) + flen; // c:3470
        tlen += (prog.len - prog.npats * patprog_size + 3) / 4; // c:3471

        // c:3463-3466 — wcfunc node.
        let wcf_flags = if (prog.flags & EF_RUN) != 0 {
            FDHF_KSHLOAD // c:3465
        } else {
            flags
        };
        progs.push(wcfunc {
            name: fname.clone(),
            prog,
            flags: wcf_flags,
        });
    }
    crate::ported::lex::set_noaliases(ona); // c:3474

    let tlen = (tlen + hlen) * 4; // c:3476

    // c:3478 — `write_dump(dfd, progs, map, hlen, tlen);` (void in C).
    let _ = write_dump(&mut dfd, &progs, map, hlen, tlen);

    0 // c:3482
}

/// Port of `cur_add_func()` from `Src/parse.c:3489` — C decl `cur_add_func(char *nam, Shfunc shf, LinkList names, LinkList progs, int *hlen, int *tlen, int what)`.
/// Adds a shfunc to the in-build dump progs+names lists. Returns 1 after
/// a `zwarnnam` when the function cannot be dumped; the caller removes the
/// half-written dump.
///
/// zshrs divergence: C parses every function into `shf->funcdef`
/// (wordcode) at definition time, so `dupeprog(shf->funcdef, 1)`
/// always has a program to copy. zshrs defers the compile — a
/// loaded user function stores its source in `shf.body` with
/// `funcdef == None` (`Src/exec.c:5540-5545`). The loaded-function arm
/// therefore falls back to `parse_string(body, 1)` to obtain the same
/// wordcode `Eprog` C would have had eagerly, using the exact substrate
/// `build_dump` feeds to `write_dump`.
pub fn cur_add_func(
    nam: &str, // c:3489
    shf: &crate::ported::zsh_h::shfunc,
    names: &mut Vec<String>,
    progs: &mut Vec<wcfunc>,
    hlen: &mut i32,
    tlen: &mut i32,
    what: i32,
) -> i32 {
    let fname = shf.node.nam.clone();
    let flags = shf.node.flags;
    let patprog_size = size_of::<*const u8>() as i32; // C `sizeof(Patprog)`

    let prog: eprog = if (flags & PM_UNDEFINED as i32) != 0 {
        // c:3495-3512 — autoload stub: only dumpable with `-a`.
        if (what & 2) == 0 {
            zwarnnam(nam, &format!("function is not loaded: {}", fname)); // c:3499
            return 1;
        }
        // c:3502 — `noaliases = (shf->node.flags & PM_UNALIASED);`
        let ona = crate::ported::lex::noaliases();
        crate::ported::lex::set_noaliases(
            (flags & crate::ported::zsh_h::PM_UNALIASED as i32) != 0,
        );
        // c:3503 — `getfpfunc(shf->node.nam, NULL, NULL, NULL, 0)`.
        let mut dir_out: Option<String> = None;
        let mut dump_out: Option<(eprog, i32)> = None;
        let found = crate::ported::exec::getfpfunc(&fname, &mut dir_out, None, 0, &mut dump_out);
        crate::ported::lex::set_noaliases(ona); // c:3506 / c:3511
        let loaded: Option<eprog> = match dump_out {
            // c:3509-3510 — `if (prog->dump) prog = dupeprog(prog, 1);`
            Some((p, _)) => Some(if p.dump.is_some() {
                dupeprog(&p, true)
            } else {
                p
            }),
            None => match found {
                // zshrs's `getfpfunc` only materializes an `Eprog`
                // for `.zwc` digest hits; a plain autoload source
                // comes back as a path. C's `getfpfunc` parses the
                // source itself — reproduce that with the same
                // read + `parse_string` path `build_dump` uses.
                Some(path) => {
                    let fnam = crate::ported::utils::unmeta(&path);
                    match fs::read(&fnam) {
                        Ok(bytes) => {
                            // Same char-form read as `build_dump`
                            // above (c:3450): `utils::metafy` cannot
                            // represent its own byte-form output in a
                            // `String` and lossily replaced any
                            // non-ASCII source char.
                            let file = crate::script_bytes::decode_script_bytes(&bytes);
                            crate::ported::exec::parse_string(&file, 1)
                        }
                        Err(_) => None,
                    }
                }
                None => None,
            },
        };
        match loaded {
            Some(p) => p,
            None => {
                zwarnnam(nam, &format!("can't load function: {}", fname)); // c:3505
                return 1;
            }
        }
    } else {
        // c:3513-3518 — loaded function: dump only with `-c`.
        if (what & 1) == 0 {
            zwarnnam(nam, &format!("function is already loaded: {}", fname)); // c:3515
            return 1;
        }
        // c:3517 — `prog = dupeprog(shf->funcdef, 1);`. In zshrs a
        // loaded function usually carries its source in `body` with
        // `funcdef == None` (deferred compile); compile it now to
        // recover the wordcode C stored eagerly.
        match &shf.funcdef {
            Some(fd) => dupeprog(fd, true),
            None => match &shf.body {
                Some(b) => match {
                    // The stored body is text the definition's parse
                    // already alias-expanded (C stores wordcode); compile
                    // it under the same lexer pins `functions` uses so an
                    // alias is not expanded a second time.
                    let _pin = crate::vm_helper::funcdef_lex_pin(&fname, b);
                    crate::ported::exec::parse_string(b, 1)
                } {
                    Some(p) => p,
                    None => {
                        zwarnnam(nam, &format!("can't load function: {}", fname));
                        return 1;
                    }
                },
                // Empty-bodied function (no funcdef, no source):
                // emit a zero-length program, matching the
                // degenerate `Eprog` C would carry for `f() { }`.
                None => eprog::default(),
            },
        }
    };

    // c:3521-3527 — build the wcfunc node.
    let wcf_flags = if (prog.flags & EF_RUN) != 0 {
        FDHF_KSHLOAD // c:3526
    } else {
        FDHF_ZSHLOAD // c:3526
    };
    // c:3531-3534 — accumulate header + body word budgets.
    *hlen += (FDHEAD_WORDS as i32) + ((fname.len() as i32 + 4) / 4); // c:3531-3532
    *tlen += (prog.len - prog.npats * patprog_size + 3) / 4; // c:3533-3534
    names.push(fname.clone()); // c:3529
    progs.push(wcfunc {
        name: fname,
        prog,
        flags: wcf_flags,
    });

    0 // c:3536
}

/// Port of `build_cur_dump()` from `Src/parse.c:3536` — C decl `build_cur_dump(char *nam, char *dump, char **names, int match, int map, int what)`.
/// Serializes the currently-loaded shell
/// functions (`-c` → `what & 1`) and/or autoloadable ones (`-a` →
/// `what & 2`) into a `.zwc` dump. Shares `write_dump` with the
/// source-file variant `build_dump`.
///
/// The per-function collection is `cur_add_func` (`Src/parse.c:3489`).
/// The shfunctab entries are cloned out first so its read lock is released
/// before `getfpfunc` (which re-locks the table on the PM_UNDEFINED
/// autoload path) runs inside `cur_add_func`.
pub fn build_cur_dump(
    nam: &str, // c:3536
    dump: &str,
    names: &[String],
    match_: i32,
    map: i32,
    what: i32,
) -> i32 {
    use crate::ported::utils::ERRFLAG_ERROR;
    use std::os::unix::fs::OpenOptionsExt;
    use std::sync::atomic::Ordering;

    // c:3542-3543 — `if (!strsfx(FD_EXT, dump)) dump = dyncat(dump, FD_EXT);`
    let dump: String = if dump.ends_with(FD_EXT) {
        dump.to_string()
    } else {
        format!("{}{}", dump, FD_EXT)
    };

    // c:3545 — `unlink(dump);`
    let _ = fs::remove_file(&dump);
    // c:3546-3549 — `open(dump, O_WRONLY|O_CREAT, 0444)`.
    let mut dfd = match fs::OpenOptions::new()
        .write(true)
        .create(true)
        .mode(0o444)
        .open(&dump)
    {
        Ok(f) => f,
        Err(_) => {
            zwarnnam(nam, &format!("can't write zwc file: {}", dump)); // c:3547
            return 1;
        }
    };

    // c:3551-3555 — `progs`/`lnames` lists, `hlen = FD_PRELEN`, `tlen = 0`.
    let mut progs: Vec<wcfunc> = Vec::new();
    let mut lnames: Vec<String> = Vec::new();
    let mut hlen = FD_PRELEN as i32;
    let mut tlen: i32 = 0;

    // Per-function candidates gathered from `shfunctab` before the
    // program serialization pass. Held as owned data so the table's
    // read lock is released before `getfpfunc` (which re-locks the
    // table on the PM_UNDEFINED autoload path) runs.
    let mut candidates: Vec<crate::ported::zsh_h::shfunc> = Vec::new();

    if names.is_empty() {
        // c:3557-3567 — no names: dump every function in the table.
        let tab = crate::ported::hashtable::shfunctab_lock()
            .read()
            .expect("shfunctab poisoned");
        for (_, shf) in tab.iter() {
            candidates.push(shf.clone());
        }
    } else if match_ != 0 {
        // c:3568-3597 — pattern match against the whole table per arg.
        for pat_name in names {
            // c:3577 — `tokenize(pat = dupstring(*names));`
            let mut tok = pat_name.clone();
            crate::ported::glob::tokenize(&mut tok);
            // c:3579 — `patcompile(pat, PAT_STATIC, NULL)`.
            let pprog = match crate::ported::pattern::patcompile(
                &tok,
                crate::ported::zsh_h::PAT_STATIC,
                None::<&mut String>,
            ) {
                Some(p) => p,
                None => {
                    zwarnnam(nam, &format!("bad pattern: {}", pat_name)); // c:3581
                    let _ = fs::remove_file(&dump); // c:3583
                    return 1;
                }
            };
            let tab = crate::ported::hashtable::shfunctab_lock()
                .read()
                .expect("shfunctab poisoned");
            // c:3586-3595 — for each function not already collected that
            // matches the pattern, add it. `lnames` is the dedup list
            // (C: `!linknodebydatum(lnames, hn->nam)`).
            for (fname, shf) in tab.iter() {
                if !candidates.iter().any(|c| c.node.nam == *fname)
                    && crate::ported::pattern::pattry(&pprog, fname)
                {
                    candidates.push(shf.clone());
                }
            }
            drop(tab);
        }
    } else {
        // c:3598-3617 — explicit names: each must resolve to a function.
        for fname in names {
            let errored = (errflag.load(Ordering::Relaxed) & ERRFLAG_ERROR) != 0;
            let tab = crate::ported::hashtable::shfunctab_lock()
                .read()
                .expect("shfunctab poisoned");
            match (errored, tab.get(fname)) {
                // c:3600-3601 — `if (errflag || !(shf = getnode(*names)))`.
                (false, Some(shf)) => {
                    candidates.push(shf.clone());
                }
                _ => {
                    drop(tab);
                    zwarnnam(nam, &format!("unknown function: {}", fname)); // c:3603
                    errflag.fetch_and(!ERRFLAG_ERROR, Ordering::Relaxed); // c:3604
                    let _ = fs::remove_file(&dump); // c:3606
                    return 1;
                }
            }
        }
    }

    for shf in &candidates {
        // c:3541-3617 — `cur_add_func(nam, shf, lnames, progs, &hlen, &tlen, what)`.
        if cur_add_func(nam, shf, &mut lnames, &mut progs, &mut hlen, &mut tlen, what) != 0 {
            errflag.fetch_and(!ERRFLAG_ERROR, Ordering::Relaxed);
            let _ = fs::remove_file(&dump);
            return 1;
        }
    }

    // c:3619-3625 — `if (empty(progs)) { zwarnnam(nam, "no functions"); ... }`
    if progs.is_empty() {
        zwarnnam(nam, "no functions"); // c:3620
        errflag.fetch_and(!ERRFLAG_ERROR, Ordering::Relaxed); // c:3621
        let _ = fs::remove_file(&dump); // c:3623
        return 1;
    }

    // c:3626 — `tlen = (tlen + hlen) * sizeof(wordcode);`
    let tlen = (tlen + hlen) * 4;

    // c:3628 — `write_dump(dfd, progs, map, hlen, tlen);`
    let _ = write_dump(&mut dfd, &progs, map, hlen, tlen);

    // c:3630 — `close(dfd);` (Rust: `dfd` drops here). Keep `lnames`
    // referenced — it mirrors C's parallel names list.
    let _ = lnames;

    0 // c:3632
}

/// Port of `zwcstat()` from `Src/parse.c:3656` — C decl `zwcstat(char *filename, struct stat *buf)`.
/// Stats a `.zwc` file, falling back to
/// `.zwc.old` if the primary doesn't exist (zsh uses the `.old`
/// suffix to keep a previous dump readable while a rewrite is in
/// progress).
pub fn zwcstat(filename: &str) -> Option<fs::Metadata> {
    // c:3656
    if let Ok(m) = fs::metadata(filename) {
        return Some(m);
    }
    let old = format!("{}.old", filename);
    fs::metadata(&old).ok()
}

/// Port of `load_dump_file()` from `Src/parse.c:3675` — C decl `load_dump_file(char *dump, struct stat *sbuf, int other, int len)`.
/// Reads (or mmap()'s) a complete `.zwc`
/// file into memory. Returns the u32 buffer or None on I/O error.
pub fn load_dump_file(
    dump: &str, // c:3675
    _sbuf: &fs::Metadata,
    other: i32,
    _len: usize,
) -> Option<Vec<u32>> {
    let mut f = File::open(dump).ok()?;
    if other != 0 {
        f.seek(SeekFrom::Start(other as u64)).ok()?;
    }
    let mut bytes = Vec::new();
    f.read_to_end(&mut bytes).ok()?;
    Some(
        bytes
            .chunks_exact(4)
            .map(|c| u32::from_le_bytes([c[0], c[1], c[2], c[3]]))
            .collect(),
    )
}

/// Port of `try_dump_file()` from `Src/parse.c:3746` — C decl `try_dump_file(char *path, char *name, char *file, int *ksh, int test_only)`.
/// Tries to load function `name` from a
/// `.zwc` digest (`<path>.zwc`) or per-function compiled file
/// (`<file>.zwc`) when each is newer than its uncompiled source.
pub fn try_dump_file(
    path: &str,
    name: &str,
    file: &str, // c:3746
    test_only: bool,
) -> Option<(eprog, i32)> {
    use std::fs;

    // c:3753-3758 — if path ends in .zwc, treat as direct digest.
    if path.ends_with(FD_EXT) {
        crate::ported::signals::queue_signals();
        let result = fs::metadata(path)
            .ok()
            .and_then(|m| check_dump_file(path, &m, name, test_only));
        unqueue_signals();
        return result;
    }

    // c:3759-3760 — dig = "<path>.zwc", wc = "<file>.zwc".
    let dig = format!("{}{}", path, FD_EXT);
    let wc = format!("{}{}", file, FD_EXT);

    // c:3762-3764 — zwcstat(dig, &std); stat(wc, &stc); stat(file, &stn);
    let std_meta = fs::metadata(&dig);
    let stc_meta = fs::metadata(&wc);
    let stn_meta = fs::metadata(file);

    crate::ported::signals::queue_signals();

    // zsh compares `st_mtime` (time_t SECONDS) with `>=` (c:3772-3780). Use
    // second-granularity mtime (MetadataExt::mtime, imported at top) — NOT
    // SystemTime (`.modified()`), whose nanosecond precision disagrees with zsh
    // whenever the dump and source share a second but differ in nsec, making
    // autoload .zwc preference flaky.

    // c:3771-3777 — use the digest when it is >= both the per-fn .zwc and the
    // source (or those are absent).
    if let Ok(std_m) = &std_meta {
        let dig_s = std_m.mtime();
        let dig_ge_wc = stc_meta.as_ref().map_or(true, |c| dig_s >= c.mtime()); // c:3772
        let dig_ge_src = stn_meta.as_ref().map_or(true, |n| dig_s >= n.mtime()); // c:3773
        if dig_ge_wc && dig_ge_src {
            if let Some(prog) = check_dump_file(&dig, std_m, name, test_only) {
                unqueue_signals();
                return Some(prog);
            }
        }
    }

    // c:3779-3784 — try per-function .zwc when it is >= the source (or absent).
    if let Ok(stc_m) = &stc_meta {
        let wc_s = stc_m.mtime();
        let src_newer_or_missing = stn_meta.as_ref().map_or(true, |n| wc_s >= n.mtime()); // c:3780
        if src_newer_or_missing {
            if let Some(prog) = check_dump_file(&wc, stc_m, name, test_only) {
                unqueue_signals();
                return Some(prog);
            }
        }
    }

    unqueue_signals(); // c:3787
    None // c:3788
}

/// Port of `try_source_file()` from `Src/parse.c:3795` — C signature `try_source_file(char *file)`.
/// Returns an Eprog (the wordcode dump body) if `<file>.zwc` exists
/// and is newer than `<file>`, else None. The dump entry searched is
/// the file's basename (`tail`), matching how `zcompile` names
/// source-file entries.
pub fn try_source_file(file: &str) -> Option<eprog> {
    // c:3795

    // c:3802-3805 — if ((tail = strrchr(file, '/'))) tail++; else tail = file;
    let tail = match file.rfind('/') {
        Some(i) => &file[i + 1..],
        None => file,
    };

    // c:3807-3812 — if (strsfx(FD_EXT, file)) { ... return check_dump_file(file, NULL, tail, NULL, 0); }
    if file.ends_with(FD_EXT) {
        crate::ported::signals::queue_signals(); // c:3808
        let meta = fs::metadata(file);
        let prog = match meta {
            Ok(m) => check_dump_file(file, &m, tail, false).map(|(p, _)| p), // c:3809
            Err(_) => None,
        };
        unqueue_signals(); // c:3810
        return prog;
    }

    // c:3813 — wc = dyncat(file, FD_EXT);
    let wc = format!("{}{}", file, FD_EXT);

    // c:3815-3816 — rc = stat(wc, &stc); rn = stat(file, &stn);
    let stc = fs::metadata(&wc);
    let stn = fs::metadata(file);

    crate::ported::signals::queue_signals(); // c:3818
                                             // c:3819-3823 — if (!rc && (rn || stc.st_mtime >= stn.st_mtime) && (prog = check_dump_file(...))) return prog;
    if let Ok(meta_c) = &stc {
        // c:3819 — `stc.st_mtime >= stn.st_mtime`: second-granularity (time_t,
        // via MetadataExt::mtime imported at top), not SystemTime nsec, to agree
        // with zsh on equal-second boundaries.
        let newer_than_src = match (&stc, &stn) {
            (Ok(c), Ok(n)) => c.mtime() >= n.mtime(),
            (Ok(_), Err(_)) => true, // c:3819 — `rn` (src missing) ⇒ accept .zwc
            _ => false,
        };
        if newer_than_src {
            let prog = check_dump_file(&wc, meta_c, tail, false); // c:3820
            if let Some((p, _)) = prog {
                unqueue_signals(); // c:3821
                return Some(p); // c:3822
            }
        }
    }
    unqueue_signals(); // c:3824
    None // c:3825
}

/// Port of `check_dump_file()` from `Src/parse.c:3833` — C decl `check_dump_file(char *file, struct stat *sbuf, char *name, int *ksh, int test_only)`.
/// Walks the `dumps` mmap list looking for `(dev, ino)` matching
/// `sbuf`; on miss, calls `load_dump_header` to read the .zwc
/// header. Then `dump_find_func(d, name)` locates the function
/// table entry. Returns the wordcode slice + ksh-load flag.
///
/// ```c
/// Eprog
/// check_dump_file(char *file, struct stat *sbuf, char *name,
///                 int *ksh, int test_only)
/// {
///     int isrec = 0;
///     Wordcode d;
///     FDHead h;
///     FuncDump f;
///     struct stat lsbuf;
///     if (!sbuf) {
///         if (zwcstat(file, &lsbuf)) return NULL;
///         sbuf = &lsbuf;
///     }
///   rec:
///     d = NULL;
///     for (f = dumps; f; f = f->next)
///         if (f->dev == sbuf->st_dev && f->ino == sbuf->st_ino)
///             { d = f->map; break; }
///     if (!f && (isrec || !(d = load_dump_header(NULL, file, 0))))
///         return NULL;
///     if ((h = dump_find_func(d, name))) {
///         if (test_only) return &dummy_eprog;
///         /* allocate Eprog from f->map at h offset, incrdumpcount,
///            return prog */
///     }
///     return NULL;
/// }
/// ```
/// Rust port returns `Option<(eprog, i32)>` instead of the C
/// `Eprog` pointer + `*ksh` out-param: tuple element 0 is the
/// loaded program (wordcode + string table per the fdhead record),
/// element 1 is the ksh-load mode exactly as C writes `*ksh`:
/// `FDHF_KSHLOAD → 2`, `FDHF_ZSHLOAD → 0`, neither → `1`
/// (c:3954-3956).
pub fn check_dump_file(
    // c:3833
    file: &str,
    sbuf: &fs::Metadata,
    name: &str,
    test_only: bool,
) -> Option<(eprog, i32)> {
    use std::os::unix::fs::MetadataExt;

    // c:3842-3846 — `if (!sbuf) { zwcstat(file, &lsbuf); sbuf = &lsbuf; }`
    // Rust takes sbuf by &Metadata — never null.
    let dev = sbuf.dev(); // c:3859
    let ino = sbuf.ino(); // c:3859

    // c:3854 — `d = NULL;`
    let mut d: Option<Vec<u32>> = None;
    let mut found_mmap = false; // c:3858 `for (f = dumps; f; ...)`

    // c:3858-3862 — walk DUMPS for matching dev/ino.
    {
        let dumps_guard = DUMPS.lock().expect("dumps poisoned");
        for f in dumps_guard.iter() {
            // c:3858
            if f.dev == dev && f.ino == ino {
                // c:3859
                d = Some(f.map.clone()); // c:3860
                found_mmap = true;
                break; // c:3861
            }
        }
    }

    // c:3870-3871 — `if (!f && (isrec || !(d = load_dump_header(NULL, file, 0)))) return NULL;`
    if !found_mmap {
        // c:3870
        match load_dump_header("", file, 0) {
            // c:3870 load_dump_header
            Some(loaded) => d = Some(loaded),
            None => return None, // c:3871
        }
    }

    // c:3873 — `if ((h = dump_find_func(d, name)))`
    let dump = d?;
    let h = dump_find_func(&dump, name)?; // c:3873

    // c:3876-3879 — `if (test_only) return &dummy_eprog;`
    if test_only {
        // c:3876
        return Some((eprog::default(), 0)); // c:3879 dummy
    }

    // c:3889-3892 / c:3929-3932 — `if (h->npats > h->len / sizeof(wordcode)) {
    // zwarn("%s: invalid description: %s", file, name); return NULL; }`: a
    // header claiming more patterns than its body has words is corrupt, and
    // the function is refused rather than run.
    if h.npats > h.len / 4 {
        crate::ported::utils::zwarn(&format!("{}: invalid description: {}", file, name));
        return None;
    }

    // c:3954-3956 — `*ksh = ((fdhflags(h) & FDHF_KSHLOAD) ? 2 :
    //                        ((fdhflags(h) & FDHF_ZSHLOAD) ? 0 : 1));`
    let ksh = if (fdhflags(&h) & FDHF_KSHLOAD) != 0 {
        2
    } else if (fdhflags(&h) & FDHF_ZSHLOAD) != 0 {
        0
    } else {
        1
    };

    // c:3919-3958 — the read (non-mmap) branch: open the file, seek
    // to the function's wordcode, read `h->len` bytes (wordcode +
    // string pool), and build an EF_REAL Eprog around it. zshrs has
    // no mmap'd EF_MAP variant — DUMPS entries store the file words
    // in `map`, so both branches funnel into the same read-and-copy.
    //
    //   if ((fd = open(file, O_RDONLY)) < 0 ||
    //       lseek(fd, ((h->start * sizeof(wordcode)) +
    //                  ((fdflags(d) & FDF_OTHER) ? fdother(d) : 0)), 0) < 0)
    //       return NULL;
    //   d = (Wordcode) zalloc(h->len + po);
    //   if (read(fd, ((char *) d) + po, h->len) != (int)h->len) return NULL;
    //   prog->flags = EF_REAL;
    //   prog->len = h->len + po;
    //   prog->npats = np = h->npats;
    //   prog->prog = (Wordcode) (((char *) d) + po);
    //   prog->strs = ((char *) prog->prog) + h->strs;
    let body_off = (h.start as u64) * 4
        + if (fdflags(&dump) & FDF_OTHER) != 0 {
            fdother(&dump) as u64 // c:3924
        } else {
            0
        };
    let mut f = File::open(file).ok()?; // c:3922
    f.seek(SeekFrom::Start(body_off)).ok()?; // c:3923
    let mut bytes = vec![0u8; h.len as usize];
    if f.read_exact(&mut bytes).is_err() {
        // c:3931 `read(...) != h->len`
        return None;
    }
    // `h->strs` is the byte offset of the string pool inside the read
    // region; everything before it is wordcode.
    let strs_off = (h.strs as usize).min(bytes.len());
    let prog_words: Vec<u32> = bytes[..strs_off]
        .chunks_exact(4)
        .map(|c| u32::from_le_bytes([c[0], c[1], c[2], c[3]]))
        .collect();
    // SAFETY: same byte-not-char convention as `bld_eprog` (c:566) —
    // consumers index `strs` by byte offset and never require UTF-8.
    let strs_string = unsafe { String::from_utf8_unchecked(bytes[strs_off..].to_vec()) };
    let po = h.npats as usize * size_of::<*const u8>(); // c:3920
    let prog = eprog {
        flags: EF_REAL,                    // c:3941
        len: (h.len as usize + po) as i32, // c:3942
        npats: h.npats as i32,             // c:3943
        nref: 1,                           // c:3944
        pats: Vec::new(),                  // c:3945/3952 dummy_patprog1 fill
        prog: prog_words,                  // c:3946
        strs: Some(strs_string),           // c:3947
        shf: None,                         // c:3948
        dump: None,                        // c:3949
        strs_metafied: true, // .zwc pool read verbatim — still METAFIED (see eprog field doc)
    };

    // c:3899 — incrdumpcount(f) on the mmap-cache hit path.
    if found_mmap {
        let dumps_guard = DUMPS.lock().expect("dumps poisoned");
        if let Some(f) = dumps_guard.iter().find(|f| f.dev == dev && f.ino == ino) {
            incrdumpcount(f); // c:3899
        }
    }

    Some((prog, ksh)) // c:3958
}

/// Port of `incrdumpcount()` from `Src/parse.c:3970` — C decl `incrdumpcount(FuncDump f)`. The `#else` (non-USE_MMAP) twin is at c:4021.
/// `f->count++;` — refcount-up a loaded dump entry. The Rust port
/// keys lookup by `filename` because Rust can't raw-pointer-compare
/// funcdump values inside a `Mutex<Vec<...>>`; same observable
/// effect (the count of the matching entry increments).
pub fn incrdumpcount(f: &funcdump) {
    // c:3970 — `f->count++;`
    if let Some(d) = DUMPS
        .lock()
        .unwrap()
        .iter_mut()
        .find(|d| d.filename.as_deref() == f.filename.as_deref())
    {
        d.count += 1; // c:3973
    }
}

/// Port of `freedump()` from `Src/parse.c:3976` — C signature `freedump(FuncDump f)`. Public
/// helper for the rare external caller; locks the dumps mutex and
/// drops the entry with the given filename.
pub fn freedump(f: &funcdump) {
    // c:3976
    let mut g = DUMPS.lock().unwrap();
    if let Some(name) = f.filename.as_deref() {
        freedump_locked(&mut g, name);
    }
}

/// Port of `decrdumpcount()` from `Src/parse.c:3988` — C decl `decrdumpcount(FuncDump f)`. The `#else` (non-USE_MMAP) twin is at c:4026.
/// `f->count--; if (!f->count) { unlink from dumps; freedump(f); }`.
pub fn decrdumpcount(f: &funcdump) {
    // c:3988
    let key = f.filename.clone();
    let mut g = DUMPS.lock().unwrap();
    let mut hit_zero: Option<String> = None;
    for d in g.iter_mut() {
        if d.filename == key {
            d.count -= 1; // c:3991
            if d.count == 0 {
                // c:3992
                hit_zero = d.filename.clone();
            }
            break;
        }
    }
    if let Some(name) = hit_zero {
        // c:3994-4001
        freedump_locked(&mut g, &name);
    }
}

/// Port of `closedumps()` from `Src/parse.c:4008` — C decl `closedumps(void)`. The `#else` (non-USE_MMAP) twin is at c:4033.
/// Walks
/// `dumps` freeing every entry. Called on shell exit (exec.c:522).
pub fn closedumps() {
    // c:4008
    let mut g = DUMPS.lock().unwrap();
    g.clear(); // c:4011-4014 `while (dumps) { ... freedump(...); ... }`
}

/// Port of `dump_autoload()` from `Src/parse.c:4042` — C decl `dump_autoload(char *nam, char *file, int on, Options ops, int func)`.
/// Registers every function in a `.zwc`
/// for autoload via `shfunctab`.
pub fn dump_autoload(
    nam: &str,
    file: &str, // c:4042
    on: i32,
    ops: &crate::ported::zsh_h::options,
    func: i32,
) -> i32 {
    use crate::ported::zsh_h::shfunc;
    let mut ret = 0; // c:4047

    // c:4049-4050 — if (!strsfx(FD_EXT, file)) file = dyncat(file, FD_EXT);
    let file_owned;
    let file = if !file.ends_with(FD_EXT) {
        file_owned = format!("{}{}", file, FD_EXT);
        file_owned.as_str()
    } else {
        file
    };

    // c:4052-4053 — if (!(h = load_dump_header(nam, file, 1))) return 1;
    let h = match load_dump_header(nam, file, 1) {
        Some(buf) => buf,
        None => return 1,
    };

    // c:4055-4056 — for (n = firstfdhead(h); n < e; n = nextfdhead(n))
    let hlen = fdheaderlen(&h) as usize; // c:4055
    let mut n_off = firstfdhead_offset();
    while n_off < hlen {
        let head = match read_fdhead(&h, n_off) {
            Some(hd) => hd,
            None => break,
        };
        // c:4057-4061 — shf = zshcalloc; shf->node.flags = on; ...addnode(fdname + fdhtail)
        let name_full = fdname(&h, n_off);
        let tail = fdhtail(&head) as usize;
        let basename: String = name_full.chars().skip(tail).collect();
        let mut shf = shfunc {
            node: crate::ported::zsh_h::hashnode {
                next: None,
                nam: basename.clone(),
                flags: on, // c:4058
            },
            filename: None,
            lineno: 0,
            funcdef: None,
            redir: None,
            sticky: None, // c:4060 NULL
            body: None,
            redir_text: None,
        };
        // c:4059 — shf->funcdef = mkautofn(shf);  (placeholder Eprog ptr)
        let _ = crate::ported::builtin::mkautofn(&mut shf as *mut _);
        // c:4061 — shfunctab->addnode(...)
        let snapshot = shf.clone();
        {
            let mut tab = crate::ported::hashtable::shfunctab_lock()
                .write()
                .expect("shfunctab poisoned");
            tab.add(shf);
        }
        // c:4062-4063 — if (OPT_ISSET(ops,'X') && eval_autoload(...)) ret = 1;
        if OPT_ISSET(ops, b'X') {
            let mut shf_ref = snapshot;
            if crate::ported::builtin::eval_autoload(&mut shf_ref as *mut _, &basename, ops, func)
                != 0
            {
                ret = 1;
            }
        }
        n_off = nextfdhead_offset(&h, n_off);
    }
    let _ = nam;
    ret // c:4065
}

/// Port of C `struct eccstr` (zsh.h:836) — the long-string dedup BST
/// node. The dedup-walk and cmp logic in `ecstrcode` is faithful to
/// parse.c:447-453 including the conditional cmp chain
/// (nfunc → hashval → strcmp), so corpus inputs where C's eccstr BST walk
/// finds-or-misses match get the same outcome on the Rust side.
#[derive(Debug, Clone)]
struct EccstrNode {
    left: Option<Box<EccstrNode>>,
    right: Option<Box<EccstrNode>>,
    /// C-byte form of the string (single byte per char ≤ 0xff).
    /// Owned because Rust doesn't have C zsh's "stable pointers into
    /// the lexer's tokstr arena" — every tokstr lives as a fresh
    /// Rust String allocation.
    str: Vec<u8>,
    /// Wordcode-encoded offset: `(byte_offset << 2) | token_bit`.
    /// Same shape as `Eccstr::offs` (parse.c:459).
    offs: u32,
    /// Absolute byte offset in the final strs region (= `ecsoffs` at
    /// insert time). C `Eccstr::aoffs` (parse.c:464). copy_ecstr uses
    /// THIS for the write position — distinct from `offs` which is
    /// ecssub-relative and collides across funcdef scopes.
    aoffs: u32,
    /// `nfunc` snapshot at insert time. Per-function namespace key
    /// — top-level scripts use 0; each funcdef bumps it.
    nfunc: i32,
    /// Hash of `str` computed via zsh's `hasher` (hashtable.c:86).
    hashval: u32,
}
// === end AST relocation ===

// Parser state lives in file-scope thread_locals:
//   - LEX_* (lexer side, matching Src/lex.c file-statics)
//   - ECBUF / ECLEN / ECUSED / ECNPATS / ECSOFFS / ECSSUB / ECNFUNC /
//     ECSTRS_INDEX / ECSTRS_REVERSE (wordcode-emission state, matching
//     Src/parse.c file-statics)
//
// Callers use the free-fn entry points directly:
//   crate::ported::parse::parse_init(input);
//   let prog = crate::ported::parse::parse();

const MAX_RECURSION_DEPTH: usize = 500;

/// Direct port of `struct parse_stack` at `Src/zsh.h:3099-3109`.
/// Used by `parse_context_save` / `parse_context_restore`
/// (parse.c:295-355) to snapshot per-parse-call state so a nested
/// parse (e.g. inside command substitution) doesn't clobber the
/// outer parse.
///
/// A second port of `struct parse_stack` exists at
/// `crate::ported::zsh_h::parse_stack` (zsh.h:1066) using canonical
/// Wordcode / Eccstr / `struct heredocs` types. This local version is the
/// one `parse_context_save` / `parse_context_restore` use; it holds the
/// wordcode-buffer state as the thread-local shapes (`Vec`, maps)
/// the emitter keeps.
#[allow(non_camel_case_types)]
#[derive(Debug, Default, Clone)]
pub struct parse_stack {
    // ── Direct port of struct parse_stack at zsh.h:3099-3109 ──
    /// Pending heredocs awaiting body collection (canonical C
    /// linked-list shape). C: `struct heredocs *hdocs` (zsh.h:3100).
    /// Mirrors `parse::HDOCS` thread_local across nested parses.
    pub hdocs: Option<Box<crate::ported::zsh_h::heredocs>>,
    /// !!! WARNING: NOT IN PARSE_STACK — Rust-only AST-glue !!!
    /// Snapshot of `lex::LEX_HEREDOCS` (the parallel Rust-only Vec
    /// carrying terminator / strip_tabs / quoted metadata).
    /// Saved/restored alongside the canonical `hdocs` so nested
    /// parses get a clean AST view. C's parse_stack has no analog
    /// because C tracks terminator metadata implicitly via tokstr.
    pub lex_heredocs: Vec<HereDoc>,
    /// C: `int incmdpos` (zsh.h:3102).
    pub incmdpos: bool,
    /// C: `int aliasspaceflag` (zsh.h:3103).
    pub aliasspaceflag: i32,
    /// C: `int incond` (zsh.h:3104).
    pub incond: i32,
    /// C: `int inredir` (zsh.h:3105).
    pub inredir: bool,
    /// C: `int incasepat` (zsh.h:3106).
    pub incasepat: i32,
    /// C: `int isnewlin` (zsh.h:3107).
    pub isnewlin: i32,
    /// C: `int infor` (zsh.h:3108).
    pub infor: i32,
    /// C: `int inrepeat_` (zsh.h:3109).
    pub inrepeat_: i32,
    /// C: `int intypeset` (zsh.h:3110).
    pub intypeset: bool,
    // ── Wordcode-buffer state (zsh.h:3112-3115) ──
    // C `int eclen, ecused, ecnpats; Wordcode ecbuf; Eccstr ecstrs;
    // int ecsoffs, ecssub, ecnfunc;` — the ECBUF family of thread-locals
    // above, saved so a nested parse (skipcomm's `parse_event(OUTPAR)`,
    // whose `init_parse` resets them) cannot clobber an enclosing wordcode
    // parse such as `zcompile`'s.
    pub eclen: i32,
    pub ecused: i32,
    pub ecnpats: i32,
    pub ecbuf: Option<Vec<u32>>,
    /// C `Eccstr ecstrs` — the long-string BST (`ECSTRS_TREE`).
    ecstrs: Option<Box<EccstrNode>>,
    /// !!! WARNING: NOT IN PARSE_STACK — Rust-only !!! The lookup index
    /// (`ECSTRS_INDEX`) and reverse map (`ECSTRS_REVERSE`) this port keeps
    /// beside the BST; C reaches both through `ecstrs` alone.
    ecstrs_index: std::collections::HashMap<(i32, String), u32>,
    ecstrs_reverse: std::collections::HashMap<u32, Vec<u8>>,
    pub ecsoffs: i32,
    pub ecssub: i32,
    pub ecnfunc: i32,
}

// Old uppercase Rust-only `ParseStack` is gone. Compat alias so
// existing call sites (context.rs) keep resolving until the
// rename ripples through.
/// `ParseStack` type alias.
#[allow(non_camel_case_types)]
pub type ParseStack = parse_stack;

/// `mod_export struct eprog dummy_eprog;` from `Src/parse.c:3066`.
/// Placeholder Eprog used by `shf->funcdef = &dummy_eprog;` in
/// builtin.c when clearing a stale autoload stub. Held in a Mutex
/// so `init_eprog` can set it once at shell startup.
pub static DUMMY_EPROG: std::sync::Mutex<eprog> = std::sync::Mutex::new(eprog {
    flags: 0,
    len: 0,
    npats: 0,
    nref: 0,
    prog: Vec::new(),
    strs: None,
    pats: Vec::new(),
    shf: None,
    dump: None,
    strs_metafied: false, // no pool (strs: None) — flag unused
});

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the post-parse here-document back-fill. C never needs it: `setheredoc`
/// (c:2347) patches the heredoc body straight into `ecbuf` at parse time,
/// while the zshrs AST records a `heredoc_idx` that this walk resolves
/// afterwards.
/// Walk every ZshRedir in the program and, for any with a `heredoc_idx`,
/// pull the body+terminator out of `bodies` and stuff into `heredoc`.
/// `bodies[i]` corresponds to the i-th heredoc registered by the lexer
/// during scanning (in source order).
fn fill_heredoc_bodies(prog: &mut ZshProgram, bodies: &[HereDocInfo]) {
    for list in &mut prog.lists {
        fill_in_sublist(&mut list.sublist, bodies);
    }
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for one recursion level of the `fill_heredoc_bodies` walk described above
/// (sublist level). No C counterpart: C patches `ecbuf` in `setheredoc`,
/// c:2347.
fn fill_in_sublist(sub: &mut ZshSublist, bodies: &[HereDocInfo]) {
    fill_in_pipe(&mut sub.pipe, bodies);
    if let Some(next) = &mut sub.next {
        fill_in_sublist(&mut next.1, bodies);
    }
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for one recursion level of the `fill_heredoc_bodies` walk described above
/// (pipeline level). No C counterpart: C patches `ecbuf` in `setheredoc`,
/// c:2347.
fn fill_in_pipe(pipe: &mut ZshPipe, bodies: &[HereDocInfo]) {
    fill_in_command(&mut pipe.cmd, bodies);
    if let Some(next) = &mut pipe.next {
        fill_in_pipe(next, bodies);
    }
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for one recursion level of the `fill_heredoc_bodies` walk described above
/// (command level). No C counterpart: C patches `ecbuf` in `setheredoc`,
/// c:2347.
fn fill_in_command(cmd: &mut ZshCommand, bodies: &[HereDocInfo]) {
    match cmd {
        ZshCommand::Simple(s) => {
            for r in &mut s.redirs {
                if let Some(idx) = r.heredoc_idx {
                    if let Some(info) = bodies.get(idx) {
                        r.heredoc = Some(info.clone());
                    }
                }
            }
        }
        ZshCommand::Subsh(p) | ZshCommand::Cursh(p) => fill_heredoc_bodies(p, bodies),
        ZshCommand::FuncDef(f) => fill_heredoc_bodies(&mut f.body, bodies),
        ZshCommand::If(i) => {
            fill_heredoc_bodies(&mut i.cond, bodies);
            fill_heredoc_bodies(&mut i.then, bodies);
            for (c, b) in &mut i.elif {
                fill_heredoc_bodies(c, bodies);
                fill_heredoc_bodies(b, bodies);
            }
            if let Some(e) = &mut i.else_ {
                fill_heredoc_bodies(e, bodies);
            }
        }
        ZshCommand::While(w) | ZshCommand::Until(w) => {
            fill_heredoc_bodies(&mut w.cond, bodies);
            fill_heredoc_bodies(&mut w.body, bodies);
        }
        ZshCommand::For(f) => fill_heredoc_bodies(&mut f.body, bodies),
        ZshCommand::Case(c) => {
            for arm in &mut c.arms {
                fill_heredoc_bodies(&mut arm.body, bodies);
            }
        }
        ZshCommand::Repeat(r) => fill_heredoc_bodies(&mut r.body, bodies),
        ZshCommand::Time(Some(sublist)) => fill_in_sublist(sublist, bodies),
        ZshCommand::Try(t) => {
            fill_heredoc_bodies(&mut t.try_block, bodies);
            fill_heredoc_bodies(&mut t.always, bodies);
        }
        ZshCommand::Redirected(inner, redirs) => {
            for r in redirs {
                if let Some(idx) = r.heredoc_idx {
                    if let Some(info) = bodies.get(idx) {
                        r.heredoc = Some(info.clone());
                    }
                }
            }
            fill_in_command(inner, bodies);
        }
        ZshCommand::Time(None) | ZshCommand::Cond(_) | ZshCommand::Arith(_) => {}
    }
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the `name()` shape test that C performs inline in `par_simple` at
/// c:2016-2028 (`if (tok == INOUTPAR)`), where the funcdef decision is made
/// against the already-emitted wordcode instead of an AST node.
/// If `list` is a Simple containing one word that ends in the
/// `<Inpar><Outpar>` token pair (the lexer-port encoding of `()`),
/// return the bare name. Used by `parse_program_until` to detect
/// `name() {body}` style function definitions where the lexer
/// hasn't split the `()` from the name.
/// Detect the `name() …` shape inside a Simple. Returns the function
/// name and (when the body was already inlined into the same Simple,
/// e.g. `foo() echo hi`) the rest of the words as the body's argv.
/// Returns None for non-funcdef shapes.
fn simple_name_with_inoutpar(list: &ZshList) -> Option<(Vec<String>, Vec<String>)> {
    if list.flags.async_ || list.sublist.next.is_some() {
        return None;
    }
    let pipe = &list.sublist.pipe;
    if pipe.next.is_some() {
        return None;
    }
    let simple = match &pipe.cmd {
        ZshCommand::Simple(s) => s,
        _ => return None,
    };
    if simple.words.is_empty() || !simple.assigns.is_empty() {
        return None;
    }
    let suffix = "\u{e188}\u{e18a}"; // Inpar + Outpar
                                 // Find the FIRST word ending in `()`. zsh accepts the
                                 // multi-name shorthand `fna fnb fnc() { body }` (parse.c:
                                 // par_funcdef wordlist) — words[0..i-1] are extra names,
                                 // words[i] is `lastname()`. Words after are the body argv
                                 // (one-line shorthand, `name() cmd args`).
    let par_idx = simple.words.iter().position(|w| w.ends_with(suffix))?;
    let mut names: Vec<String> = Vec::with_capacity(par_idx + 1);
    for w in &simple.words[..par_idx] {
        // Earlier names must be bare identifiers, NOT contain
        // tokens that imply they're not function names (no `()`,
        // no quotes, no expansions). zsh's lexer enforces this
        // at the wordlist level; we approximate by requiring the
        // word be an identifier-shaped token after untokenize.
        let bare = super::lex::untokenize(w);
        let valid = !bare.is_empty()
            && bare
                .chars()
                .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-' || c == '.' || c == '$');
        if !valid {
            return None;
        }
        names.push(bare);
    }
    let last = &simple.words[par_idx];
    let bare = &last[..last.len() - suffix.len()];
    if bare.is_empty() {
        return None;
    }
    // c:Src/lex.c:2164 `skipcomm` — an EMPTY command substitution `$()`
    // reaches the parser as `String`/`Qstring` immediately followed by the
    // `Inpar`…`Outpar` pair the lexer stamped around the (empty) body, so
    // the word's tail is byte-identical to the funcdef `name()` shape. C
    // never confuses them because a funcdef arrives as a separate
    // `INOUTPAR` token (c:Src/parse.c:2051 par_simple) while `$()`'s
    // parens are consumed inside the word. Here the two shapes are told
    // apart by what precedes the parens: a `$` marker means command
    // substitution, so `print a $() b` is a plain command, not a
    // definition of a function named `$`.
    if bare.ends_with(crate::ported::zsh_h::Stringg)
        || bare.ends_with(crate::ported::zsh_h::Qstring)
        || bare.ends_with('$')
    {
        return None;
    }
    names.push(super::lex::untokenize(bare));
    let rest = simple.words[par_idx + 1..].to_vec();
    Some((names, rest))
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for a parse-only entry point that seeds the option defaults the lexer
/// reads. C gets those from `install_emulation_defaults` (Src/options.c) at
/// startup and its parser only READS options; `init_parse` (c:509) and
/// `init_parse_status` (c:491) are the real C initialisers and are ported
/// separately.
/// Initialize parser state for a fresh parse of `input`.
/// Free-fn entry point — resets parser thread_locals and loads input.
pub fn parse_init(input: &str) {
    // Seed the option defaults the parser/lexer inspect. Real zsh
    // installs these via `install_emulation_defaults` (options.c:172)
    // at shell startup; zshrs's parse-only test entry path bypasses
    // init_main, so we mirror the `zsh` emulation defaults here.
    //
    // Under `cfg(test)` (lib unit tests share one process) we
    // unconditionally OVERWRITE these on every parse_init so cross-
    // test option pollution (a prior test that flipped one of these
    // and panicked before its restore ran) doesn't leak into the
    // parser's reserved-word recognition / one-liner detection.
    //
    // In the REAL shell this overwrite is WRONG: parse_init runs for
    // every -c string, eval, and cmd-subst body, so resetting
    // `posixbuiltins` here silently wiped `zshrs -o POSIX_BUILTINS`
    // and made `setopt posix_builtins` evaporate at the next parse
    // (A04redirect.ztst POSIX_BUILTINS chunks). C zsh's parser READS
    // options; it never writes them. Production seeds only entries
    // that are missing entirely (parse-only test paths that bypass
    // init_main still get the zsh-emulation defaults).
    let overwrite = cfg!(test);
    for (name, default) in [
        ("shortloops", true),
        ("shortrepeat", false),
        ("multifuncdef", true),
        ("aliasfuncdef", false),
        ("ignorebraces", false),
        ("cshjunkieloops", false),
        ("posixbuiltins", false),
        ("execopt", true),
        ("kshautoload", false),
        ("aliases", true),
    ] {
        if overwrite || crate::ported::options::opt_state_get(name).is_none() {
            crate::ported::options::opt_state_set(name, default);
        }
    }
    lex_init(input);
}

/// Port of `ecgetstr` from `Src/parse.c:2855` — C decl `ecgetstr(Estate s, int dup, int *tokflag)`. Rust fn `ecgetstr_wordcode` is the wordcode-pipeline decoder variant; the AST-side `ecgetstr` is at parse.rs:3869.
/// P9b decoder (wordcode-pipeline variant): direct port of
/// `ecgetstr(Estate s, int dup, int *tokflag)` from
/// `Src/parse.c:2855-2890`. Reads a wordcode at `pc`, decodes the
/// encoded string back to owned String. Returns (string,
/// pc_after_consumed). Distinct from the existing `ecgetstr` (which
/// takes a separate strs buffer for text.rs) — this variant uses
/// the live ECSTRS_REVERSE HashMap populated at ecstrcode time.
pub fn ecgetstr_wordcode(buf: &[u32], pc: usize) -> (String, usize) {
    if pc >= buf.len() {
        return (String::new(), pc);
    }
    let c = buf[pc];
    let next = pc + 1;
    // parse.c:2862-2863 — empty-string sentinels.
    if c == 6 || c == 7 {
        return (String::new(), next);
    }
    // parse.c:2864-2871 — inline-packed short string.
    if (c & 2) != 0 {
        let b0 = ((c >> 3) & 0xff) as u8;
        let b1 = ((c >> 11) & 0xff) as u8;
        let b2 = ((c >> 19) & 0xff) as u8;
        let mut bytes: Vec<u8> = Vec::new();
        for b in [b0, b1, b2] {
            if b == 0 {
                break;
            }
            bytes.push(b);
        }
        return (String::from_utf8_lossy(&bytes).into_owned(), next);
    }
    // parse.c:2872-2873 — long string via offs lookup. Map value is
    // metafied Vec<u8>; convert back to display String. Unmetafy is
    // the caller's job (the wordcode-parity dumper does it; other
    // callers may want raw bytes).
    let s = ECSTRS_REVERSE
        .with_borrow(|m| m.get(&c).cloned())
        .map(|v| String::from_utf8_lossy(&v).into_owned())
        .unwrap_or_default();
    (s, next)
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the AST-pipeline top-level driver. C's equivalents are `parse_event`
/// (c:614) and `par_event` (c:635), both ported separately; this entry loops
/// `parse_program_until` instead of emitting wordcode.
/// Parse the complete input. Direct port of `parse_event` /
/// `par_list` from `Src/parse.c:614-720`. On syntax error,
/// sets `errflag |= ERRFLAG_ERROR` (via `zerr`) and returns the
/// partial program — callers check `errflag` to detect failure,
/// matching C's `Eprog parse_event(...)` + `if (errflag) {...}`.
pub fn parse() -> ZshProgram {
    zshlex();

    let mut program = parse_program_until(None, false);

    // Post-pass: wire heredoc bodies (collected by the inline NEWLIN
    // walk in zshlex into LEX_HEREDOCS) back into ZshRedir.heredoc
    // fields via heredoc_idx. No C analog — LEX_HEREDOCS is the
    // Rust-only AST-glue Vec.
    let bodies: Vec<HereDocInfo> = LEX_HEREDOCS
        .with_borrow(|v| v.clone())
        .into_iter()
        .map(|h| HereDocInfo {
            content: h.content,
            terminator: h.terminator,
            quoted: h.quoted,
        })
        .collect();
    if !bodies.is_empty() {
        fill_heredoc_bodies(&mut program, &bodies);
    }

    program
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the wordcode-pipeline top-level driver. C's closest analogue is
/// `parse_list` (c:697), but that calls `init_parse` + `par_list` +
/// `bld_eprog`; this entry only drives `par_list_wordcode`, leaving
/// init/build to the caller.
/// Wordcode-emission top-level driver. Closest C analog is
/// `parse_list(void)` at `Src/parse.c:697-712`: init_parse +
/// zshlex + par_list(&c) + bld_eprog. This entry omits init_parse
/// and bld_eprog (caller responsibilities) and inlines a guard
/// loop around par_list_wordcode for cases where the lexer leaves
/// a non-ENDINPUT terminator (LEXERR, missing close-token, etc.).
pub fn par_event_wordcode() -> usize {
    let start = ECUSED.get() as usize;
    // C `parse_list` (parse.c:697-712) calls par_list ONCE — par_list's
    // own goto-rec loop handles all SEPER-separated sublists. The
    // outer loop here exists for safety against early-return cases
    // (LEXERR, missing terminator) but normally par_list_wordcode
    // consumes everything in one call.
    let mut cmplx: i32 = 0;
    while tok() != ENDINPUT && tok() != LEXERR {
        par_list_wordcode(&mut cmplx);
        match tok() {
            SEMI | NEWLIN | AMPER | AMPERBANG | SEPER => {
                zshlex();
            }
            _ => break,
        }
    }
    // No trailing `ecadd(WCB_END())` here: C's `par_list` (c:769)
    // emits none — the single terminating `WCB_END` comes from
    // `bld_eprog` (c:555). Emitting one here too made every program
    // one word longer than C's (double END), breaking .zwc dump
    // byte-parity with `zcompile`.
    start
}

/// Port of `par_list` from `Src/parse.c:771` — C decl `par_list(int *cmplx)`. Rust fn `par_list_wordcode` is the wordcode-emitting variant (the AST twin is `par_list` at parse.rs:1008).
/// `list : { SEPER } [ sublist [ { SEPER | AMPER | AMPERBANG } list ] ]`.
/// True line-by-line port: takes `cmplx: &mut i32` matching C's
/// `int *cmplx` out-parameter, uses stack-local `c` per iteration
/// like C (so inner sublist cmplx is independent of outer).
pub fn par_list_wordcode(cmplx: &mut i32) {
    // c:773 — `int p, lp = -1, c;`
    let mut p: usize;
    let mut lp: i32 = -1;
    let mut c: i32;
    loop {
        // c:775 `rec:` — c:777-778 `while (tok == SEPER) zshlex();`
        while tok() == SEPER {
            zshlex();
        }
        // c:780 — `p = ecadd(0);`
        p = ecadd(0);
        // c:781 — `c = 0;`
        c = 0;
        // c:783 — `if (par_sublist(&c)) { ... }`
        if par_sublist_wordcode(&mut c) {
            // c:784 — `*cmplx |= c;`
            *cmplx |= c;
            // c:785 — `if (tok == SEPER || tok == AMPER || tok == AMPERBANG)`
            let t = tok();
            if t == SEPER || t == AMPER || t == AMPERBANG {
                // c:786-787 — `if (tok != SEPER) *cmplx = 1;`
                if t != SEPER {
                    *cmplx = 1;
                }
                // c:788-790 — `set_list_code(p, ..., c);`
                let z = if t == SEPER {
                    Z_SYNC
                } else if t == AMPER {
                    Z_ASYNC
                } else {
                    Z_ASYNC | Z_DISOWN
                };
                set_list_code(p, z, c != 0);
                // c:791 — `incmdpos = 1;`
                set_incmdpos(true);
                // c:792-794 — `do { zshlex(); } while (tok == SEPER);`
                loop {
                    zshlex();
                    if tok() != SEPER {
                        break;
                    }
                }
                // c:795 — `lp = p;` c:796 — `goto rec;`
                lp = p as i32;
                continue;
            } else {
                // c:798 — `set_list_code(p, (Z_SYNC | Z_END), c);`
                set_list_code(p, Z_SYNC | Z_END, c != 0);
            }
        } else {
            // c:800-802 — `ecused--; if (lp >= 0) ecbuf[lp] |= wc_bdata(Z_END);`
            ECUSED.set((ECUSED.get() - 1).max(0));
            if lp >= 0 {
                ECBUF.with_borrow_mut(|b| {
                    if (lp as usize) < b.len() {
                        b[lp as usize] |= wc_bdata(Z_END as wordcode);
                    }
                });
            }
        }
        break;
    }
}

/// Port of `par_list1` from `Src/parse.c:808` — C decl `par_list1(int *cmplx)`. Rust fn `par_list1_wordcode` is the wordcode-emitting variant.
/// Single-sublist variant used by funcdef bodies and the short
/// `for`/`while`/`repeat` forms — exactly one sublist with
/// `Z_SYNC|Z_END`, no chain.
pub fn par_list1_wordcode(cmplx: &mut i32) {
    // c:810 — `int p = ecadd(0), c = 0;`
    let p = ecadd(0);
    let mut c: i32 = 0;
    // c:812 — `if (par_sublist(&c)) { ... }`
    if par_sublist_wordcode(&mut c) {
        // c:813 — `set_list_code(p, (Z_SYNC | Z_END), c);`
        set_list_code(p, Z_SYNC | Z_END, c != 0);
        // c:814 — `*cmplx |= c;`
        *cmplx |= c;
    } else {
        // c:816 — `ecused--;`
        ECUSED.set((ECUSED.get() - 1).max(0));
    }
}

/// Port of `par_save_list` from `Src/parse.c:475` — C decl `#define par_save_list(C) do { int eu = ecused; par_list(C); if (eu == ecused) ecadd(WCB_END()); } while (0)`. Rust fn `par_save_list_wordcode` is the wordcode-emitting variant of that C macro.
///   do { int eu = ecused; par_list(C); if (eu == ecused) ecadd(WCB_END()); } while (0)
pub fn par_save_list_wordcode(cmplx: &mut i32) {
    let eu = ECUSED.get();
    par_list_wordcode(cmplx);
    if ECUSED.get() == eu {
        ecadd(WCB_END());
    }
}

/// Port of `par_save_list1` from `Src/parse.c:481` — C decl `#define par_save_list1(C) do { int eu = ecused; par_list1(C); if (eu == ecused) ecadd(WCB_END()); } while (0)`. Rust fn `par_save_list1_wordcode` is the wordcode-emitting variant of that C macro.
pub fn par_save_list1_wordcode(cmplx: &mut i32) {
    let eu = ECUSED.get();
    par_list1_wordcode(cmplx);
    if ECUSED.get() == eu {
        ecadd(WCB_END());
    }
}

/// Port of `par_sublist` from `Src/parse.c:825` — C decl `par_sublist(int *cmplx)`. Rust fn `par_sublist_wordcode` is the wordcode-emitting variant.
/// `sublist : sublist2 [ ( DBAR | DAMPER ) { SEPER } sublist ]`.
/// Emits a WCB_SUBLIST header, recurses into par_sublist2 for
/// the !/coproc prefix + pipeline, then chains via DBAR (`||`)
/// or DAMPER (`&&`) recursively. Returns true if at least one
/// pipeline was emitted.
pub fn par_sublist_wordcode(cmplx: &mut i32) -> bool {
    // c:827 — `int f, p, c = 0;`
    let mut c: i32 = 0;
    // c:829 — `p = ecadd(0);`
    let p = ecadd(0);
    // c:831 — `if ((f = par_sublist2(&c)) != -1) { ... }`
    match par_sublist2(&mut c) {
        Some(f) => {
            // c:832 — `int e = ecused;`
            let e = ECUSED.get() as usize;
            // c:834 — `*cmplx |= c;`
            *cmplx |= c;
            if tok() == DBAR || tok() == DAMPER {
                // c:836 — `enum lextok qtok = tok;`
                let qtok = tok();
                // c:839 — `cmdpush(tok == DBAR ? CS_CMDOR : CS_CMDAND);`
                cmdpush(if qtok == DBAR {
                    CS_CMDOR as u8
                } else {
                    CS_CMDAND as u8
                });
                // c:840 — `zshlex();`
                zshlex();
                // c:841-842 — `while (tok == SEPER) zshlex();`
                while tok() == SEPER {
                    zshlex();
                }
                // c:843 — `sl = par_sublist(cmplx);`
                let sl = par_sublist_wordcode(cmplx);
                // c:844-847 — `set_sublist_code(p, (sl ? ... : WC_SUBLIST_END),
                // f, (e - 1 - p), c);`
                let st = if sl {
                    if qtok == DBAR {
                        WC_SUBLIST_OR
                    } else {
                        WC_SUBLIST_AND
                    }
                } else {
                    WC_SUBLIST_END
                };
                set_sublist_code(p, st as i32, f, (e - 1 - p) as i32, c != 0);
                // c:848 — `cmdpop();`
                cmdpop();
            } else {
                // c:850-853 — `if (tok == AMPER || tok == AMPERBANG)
                // { c = 1; *cmplx |= c; }`
                if tok() == AMPER || tok() == AMPERBANG {
                    c = 1;
                    *cmplx |= c;
                }
                // c:854 — `set_sublist_code(p, WC_SUBLIST_END, f,
                // (e - 1 - p), c);`
                set_sublist_code(p, WC_SUBLIST_END as i32, f, (e - 1 - p) as i32, c != 0);
            }
            // c:856 — `return 1;`
            true
        }
        None => {
            // c:858-859 — `ecused--; return 0;`
            ECUSED.set((ECUSED.get() - 1).max(0));
            false
        }
    }
}

/// Port of `par_pline` from `Src/parse.c:894` — C decl `par_pline(int *cmplx)`. Rust fn `par_pipe_wordcode` is the wordcode-emitting variant; named `par_pipe_wordcode` because the AST `par_pline` (parse.rs:1183) already owns the C name.
/// `pline : cmd [ ( BAR | BARAMP ) { SEPER } pline ]`. Emits a
/// WCB_PIPE header (mid for chain links, end for the last cmd)
/// plus the optional BARAMP `2>&1` synthetic redir.
/// (Named `par_pipe_wordcode` to disambiguate from the AST
/// `par_pline` at parse.rs:1183 — semantically the same `pline`
/// production.)
pub fn par_pipe_wordcode(cmplx: &mut i32) -> bool {
    // c:897 — `zlong line = toklineno;`
    let line = toklineno() as i64;
    // c:899 — `p = ecadd(0);`
    let p = ecadd(0);
    // c:901-904 — `if (!par_cmd(cmplx, 0)) { ecused--; return 0; }`
    if !par_cmd_wordcode(cmplx, 0) {
        ECUSED.set((ECUSED.get() - 1).max(0));
        return false;
    }
    if tok() == BAR_TOK {
        // c:906 — `*cmplx = 1;`
        *cmplx = 1;
        // c:907 — `cmdpush(CS_PIPE);`
        cmdpush(CS_PIPE as u8);
        // c:908 — `zshlex();`
        zshlex();
        // c:909-910 — `while (tok == SEPER) zshlex();`
        while tok() == SEPER {
            zshlex();
        }
        // c:911 — `ecbuf[p] = WCB_PIPE(WC_PIPE_MID, line>=0 ? line+1 : 0);`
        ECBUF.with_borrow_mut(|b| {
            if p < b.len() {
                b[p] = WCB_PIPE(
                    WC_PIPE_MID,
                    if line >= 0 { (line + 1) as wordcode } else { 0 },
                );
            }
        });
        // c:912 — `ecispace(p+1, 1);`
        ecispace(p + 1, 1);
        // c:913 — `ecbuf[p+1] = ecused - 1 - p;`
        let used = ECUSED.get() as usize;
        ECBUF.with_borrow_mut(|b| {
            if p + 1 < b.len() {
                b[p + 1] = (used.saturating_sub(1 + p)) as wordcode;
            }
        });
        // c:914-916 — `if (!par_pline(cmplx)) { tok = LEXERR; }`
        if !par_pipe_wordcode(cmplx) {
            set_tok(LEXERR);
        }
        // c:917 — `cmdpop();`
        cmdpop();
        true
    } else if tok() == BARAMP {
        // c:920-923 — walk past inline WC_REDIR to find r.
        let mut r = p + 1;
        loop {
            let code = ECBUF.with_borrow(|b| b.get(r).copied().unwrap_or(0));
            if wc_code(code) != WC_REDIR {
                break;
            }
            r += WC_REDIR_WORDS(code) as usize;
        }
        // c:925-928 — `ecispace(r, 3);` + synthetic `2>&1` redir
        ecispace(r, 3);
        ECBUF.with_borrow_mut(|b| {
            if r + 2 < b.len() {
                b[r] = WCB_REDIR(REDIR_MERGEOUT as wordcode);
                b[r + 1] = 2;
                b[r + 2] = ecstrcode("1");
            }
        });
        // c:930 — `*cmplx = 1;`
        *cmplx = 1;
        cmdpush(CS_ERRPIPE as u8);
        zshlex();
        while tok() == SEPER {
            zshlex();
        }
        ECBUF.with_borrow_mut(|b| {
            if p < b.len() {
                b[p] = WCB_PIPE(
                    WC_PIPE_MID,
                    if line >= 0 { (line + 1) as wordcode } else { 0 },
                );
            }
        });
        ecispace(p + 1, 1);
        let used = ECUSED.get() as usize;
        ECBUF.with_borrow_mut(|b| {
            if p + 1 < b.len() {
                b[p + 1] = (used.saturating_sub(1 + p)) as wordcode;
            }
        });
        if !par_pipe_wordcode(cmplx) {
            set_tok(LEXERR);
        }
        cmdpop();
        true
    } else {
        // c:944 — `ecbuf[p] = WCB_PIPE(WC_PIPE_END, line>=0 ? line+1 : 0);`
        ECBUF.with_borrow_mut(|b| {
            if p < b.len() {
                b[p] = WCB_PIPE(
                    WC_PIPE_END,
                    if line >= 0 { (line + 1) as wordcode } else { 0 },
                );
            }
        });
        true
    }
}

/// Port of `par_cmd` from `Src/parse.c:958` — C decl `par_cmd(int *cmplx, int zsh_construct)`. Rust fn `par_cmd_wordcode` is the wordcode-emitting variant.
/// Parses leading + trailing redirs and
/// dispatches on the current token to the right par_* builder.
/// Returns false only when no command was emitted (no redirs +
/// par_simple returned 0).
pub fn par_cmd_wordcode(cmplx: &mut i32, zsh_construct: i32) -> bool {
    // c:960 — `int r, nr = 0;`
    let mut nr: i32 = 0;
    // c:962 — `r = ecused;`
    let mut r: usize = ECUSED.get() as usize;
    // c:964-968 — leading redirs.
    if IS_REDIROP(tok()) {
        // c:965 — `*cmplx = 1;`
        *cmplx = 1;
        // c:966-968 — `while (IS_REDIROP(tok)) { nr += par_redir(&r, NULL); }`
        while IS_REDIROP(tok()) {
            nr += par_redir_wordcode(&mut r, None);
        }
    }
    // c:970-1066 — token-dispatch switch.
    match tok() {
        FOR => {
            cmdpush(CS_FOR as u8);
            par_for_wordcode(cmplx);
            cmdpop();
        }
        FOREACH => {
            cmdpush(CS_FOREACH as u8);
            par_for_wordcode(cmplx);
            cmdpop();
        }
        SELECT => {
            // c:982 — `*cmplx = 1;`
            *cmplx = 1;
            cmdpush(CS_SELECT as u8);
            par_for_wordcode(cmplx);
            cmdpop();
        }
        CASE => {
            cmdpush(CS_CASE as u8);
            par_case_wordcode(cmplx);
            cmdpop();
        }
        IF => {
            par_if_wordcode(cmplx);
        }
        WHILE => {
            cmdpush(CS_WHILE as u8);
            par_while_wordcode(cmplx);
            cmdpop();
        }
        UNTIL => {
            cmdpush(CS_UNTIL as u8);
            par_while_wordcode(cmplx);
            cmdpop();
        }
        REPEAT => {
            cmdpush(CS_REPEAT as u8);
            par_repeat_wordcode(cmplx);
            cmdpop();
        }
        INPAR_TOK => {
            // c:1011 — `*cmplx = 1;`
            *cmplx = 1;
            cmdpush(CS_SUBSH as u8);
            par_subsh_wordcode(cmplx, zsh_construct);
            cmdpop();
        }
        INBRACE_TOK => {
            cmdpush(CS_CURSH as u8);
            par_subsh_wordcode(cmplx, zsh_construct);
            cmdpop();
        }
        FUNC => {
            cmdpush(CS_FUNCDEF as u8);
            par_funcdef_wordcode(cmplx);
            cmdpop();
        }
        DINBRACK => {
            cmdpush(CS_COND as u8);
            par_cond_wordcode();
            cmdpop();
        }
        DINPAR => {
            par_arith_wordcode();
        }
        TIME => {
            // c:1037-1050 — `static int inpartime` guard so
            // `time time foo` doesn't recurse infinitely.
            if !PARSER_INPARTIME.with(|c| c.get()) {
                // c:1041 — `*cmplx = 1;`
                *cmplx = 1;
                PARSER_INPARTIME.with(|c| c.set(true));
                par_time_wordcode();
                PARSER_INPARTIME.with(|c| c.set(false));
            } else {
                set_tok(STRING_LEX);
                let sr = par_simple_wordcode(cmplx, nr);
                if sr == 0 && nr == 0 {
                    return false;
                }
                if sr > 1 {
                    *cmplx = 1;
                    r += (sr - 1) as usize;
                }
            }
        }
        _ => {
            // c:1054 — `if (!(sr = par_simple(cmplx, nr)))`
            let sr = par_simple_wordcode(cmplx, nr);
            if sr == 0 {
                if nr == 0 {
                    return false;
                }
            } else if sr > 1 {
                // c:1060-1061 — `*cmplx = 1; r += sr - 1;`
                *cmplx = 1;
                r += (sr - 1) as usize;
            }
        }
    }
    // c:1067-1071 — trailing redirs.
    // c:1067 — `if (IS_REDIROP(tok)) { *cmplx = 1; while (...) (void)par_redir(&r, NULL); }`
    if IS_REDIROP(tok()) {
        *cmplx = 1;
        while IS_REDIROP(tok()) {
            let _ = par_redir_wordcode(&mut r, None);
        }
    }
    // c:1072-1075 — `incmdpos=1; incasepat=0; incond=0; intypeset=0;`
    set_incmdpos(true);
    set_incasepat(0);
    set_incond(0);
    set_intypeset(false);
    let _ = r;
    // c:1076 — `return 1;`
    true
}

/// Port of `par_for` from `Src/parse.c:1087` — C decl `par_for(int *cmplx)`. Rust fn `par_for_wordcode` is the wordcode-emitting variant.
pub fn par_for_wordcode(cmplx: &mut i32) {
    // c:1089 — `int oecused = ecused, csh = (tok == FOREACH), p, sel = (tok == SELECT);`
    let oecused = ECUSED.get() as usize;
    let csh = tok() == FOREACH;
    let sel = tok() == SELECT;
    let p: usize;
    // c:1090 — `int type;`
    let r#type: wordcode;

    // c:1092 — `p = ecadd(0);`
    p = ecadd(0);

    // c:1094 — `incmdpos = 0;`
    set_incmdpos(false);
    // c:1095 — `infor = tok == FOR ? 2 : 0;`
    set_infor(if tok() == FOR { 2 } else { 0 });
    // c:1096 — `zshlex();`
    zshlex();
    // c:1097 — `if (tok == DINPAR) {`
    if tok() == DINPAR {
        // c:1098 — `zshlex();`
        zshlex();
        // c:1099-1100 — `if (tok != DINPAR) YYERRORV(oecused);`
        if tok() != DINPAR {
            YYERRORV!(oecused);
        }
        // c:1101 — `ecstr(tokstr);`
        ecstr(&tokstr().unwrap_or_default());
        // c:1102 — `zshlex();`
        zshlex();
        // c:1103-1104
        if tok() != DINPAR {
            YYERRORV!(oecused);
        }
        // c:1105
        ecstr(&tokstr().unwrap_or_default());
        // c:1106
        zshlex();
        // c:1107-1108
        if tok() != DOUTPAR {
            YYERRORV!(oecused);
        }
        // c:1109
        ecstr(&tokstr().unwrap_or_default());
        // c:1110 — `infor = 0;`
        set_infor(0);
        // c:1111 — `incmdpos = 1;`
        set_incmdpos(true);
        // c:1112 — `zshlex();`
        zshlex();
        // c:1113 — `type = WC_FOR_COND;`
        r#type = WC_FOR_COND;
    } else {
        // c:1115 — `int np = 0, n, posix_in, ona = noaliases, onc = nocorrect;`
        let mut np: usize = 0;
        let mut n: u32;
        let posix_in: bool;
        let ona = noaliases();
        let onc = nocorrect();
        // c:1116 — `infor = 0;`
        set_infor(0);
        // c:1117-1118 — `if (tok != STRING || !isident(tokstr)) YYERRORV(oecused);`
        if tok() != STRING_LEX || !crate::ported::params::isident(&tokstr().unwrap_or_default()) {
            YYERRORV!(oecused);
        }
        // c:1119-1120 — `if (!sel) np = ecadd(0);`
        if !sel {
            np = ecadd(0);
        }
        // c:1121 — `n = 0;`
        n = 0;
        // c:1122 — `incmdpos = 1;`
        set_incmdpos(true);
        // c:1123 — `noaliases = nocorrect = 1;`
        set_noaliases(true);
        set_nocorrect(1);
        // c:1124 — `for (;;) {`
        loop {
            // c:1125 — `n++;`
            n += 1;
            // c:1126 — `ecstr(tokstr);`
            ecstr(&tokstr().unwrap_or_default());
            // c:1127 — `zshlex();`
            zshlex();
            // c:1128-1129 — `if (tok != STRING || !strcmp(tokstr, "in") || sel) break;`
            if tok() != STRING_LEX || tokstr().as_deref() == Some("in") || sel {
                break;
            }
            // c:1130-1135 — `if (!isident(tokstr) || errflag) { ... YYERRORV; }`
            if !crate::ported::params::isident(&tokstr().unwrap_or_default())
                || (errflag.load(Ordering::Relaxed) & 1) != 0
            {
                set_noaliases(ona);
                set_nocorrect(onc);
                YYERRORV!(oecused);
            }
        }
        // c:1137-1138 — `noaliases = ona; nocorrect = onc;`
        set_noaliases(ona);
        set_nocorrect(onc);
        // c:1139-1140 — `if (!sel) ecbuf[np] = n;`
        if !sel {
            ECBUF.with_borrow_mut(|b| {
                b[np] = n;
            });
        }
        // c:1141 — `posix_in = isnewlin;`
        posix_in = isnewlin() != 0;
        // c:1142-1143 — `while (isnewlin) zshlex();`
        while isnewlin() != 0 {
            zshlex();
        }
        // c:1144 — `if (tok == STRING && !strcmp(tokstr, "in")) {`
        if tok() == STRING_LEX && tokstr().as_deref() == Some("in") {
            // c:1145 — `incmdpos = 0;`
            set_incmdpos(false);
            // c:1146 — `zshlex();`
            zshlex();
            // c:1147 — `np = ecadd(0);`
            np = ecadd(0);
            // c:1148 — `n = par_wordlist();`
            let n2 = par_wordlist_wordcode();
            // c:1149-1150 — `if (tok != SEPER) YYERRORV(oecused);`
            if tok() != SEPER {
                YYERRORV!(oecused);
            }
            // c:1151 — `ecbuf[np] = n;`
            ECBUF.with_borrow_mut(|b| {
                b[np] = n2 as wordcode;
            });
            // c:1152 — `type = (sel ? WC_SELECT_LIST : WC_FOR_LIST);`
            r#type = if sel { WC_SELECT_LIST } else { WC_FOR_LIST };
        } else if !posix_in && tok() == INPAR_TOK {
            // c:1153-1154 — `else if (!posix_in && tok == INPAR)`
            // c:1154 — `incmdpos = 0;`
            set_incmdpos(false);
            // c:1155 — `zshlex();`
            zshlex();
            // c:1156 — `np = ecadd(0);`
            np = ecadd(0);
            // c:1157 — `n = par_nl_wordlist();`
            let n2 = par_nl_wordlist_wordcode();
            // c:1158-1159 — `if (tok != OUTPAR) YYERRORV(oecused);`
            if tok() != OUTPAR_TOK {
                YYERRORV!(oecused);
            }
            // c:1160 — `ecbuf[np] = n;`
            ECBUF.with_borrow_mut(|b| {
                b[np] = n2 as wordcode;
            });
            // c:1161 — `incmdpos = 1;`
            set_incmdpos(true);
            // c:1162 — `zshlex();`
            zshlex();
            // c:1163 — `type = (sel ? WC_SELECT_LIST : WC_FOR_LIST);`
            r#type = if sel { WC_SELECT_LIST } else { WC_FOR_LIST };
        } else {
            // c:1165 — `type = (sel ? WC_SELECT_PPARAM : WC_FOR_PPARAM);`
            r#type = if sel { WC_SELECT_PPARAM } else { WC_FOR_PPARAM };
        }
        let _ = np;
    }
    // c:1167 — `incmdpos = 1;`
    set_incmdpos(true);
    // c:1168-1169 — `while (tok == SEPER) zshlex();`
    while tok() == SEPER {
        zshlex();
    }
    // c:1170-1193 — body dispatch (inline in C, factored here for
    // reuse by par_while/par_repeat — same control flow, same calls).
    par_loop_body_wordcode(cmplx, csh, oecused);
    // c:1195-1197 — `ecbuf[p] = (sel ? WCB_SELECT(...) : WCB_FOR(...));`
    let used = ECUSED.get() as usize;
    let off = used.saturating_sub(1 + p) as wordcode;
    ECBUF.with_borrow_mut(|b| {
        b[p] = if sel {
            WCB_SELECT(r#type, off)
        } else {
            WCB_FOR(r#type, off)
        };
    });
}

/// Port of `par_wordlist` from `Src/parse.c:2362` — C decl `par_wordlist(void)`. Rust fn `par_wordlist_wordcode` is the wordcode-emitting variant.
/// emits wordcode form. Returns the number of strings emitted.
fn par_wordlist_wordcode() -> u32 {
    // c:2364 — `int num = 0;`
    let mut num: u32 = 0;
    // c:2365 — `while (tok == STRING) {`
    while tok() == STRING_LEX {
        // c:2366 — `ecstr(tokstr);`
        ecstr(&tokstr().unwrap_or_default());
        // c:2367 — `num++;`
        num += 1;
        // c:2368 — `zshlex();`
        zshlex();
    }
    // c:2370 — `return num;`
    num
}

/// Port of `par_nl_wordlist` from `Src/parse.c:2379` — C decl `par_nl_wordlist(void)`. Rust fn `par_nl_wordlist_wordcode` is the wordcode-emitting variant.
/// emits wordcode form. Like par_wordlist but tolerates SEPER
/// between words.
fn par_nl_wordlist_wordcode() -> u32 {
    // c:2381 — `int num = 0;`
    let mut num: u32 = 0;
    // c:2383 — `while (tok == STRING || tok == SEPER) {`
    while tok() == STRING_LEX || tok() == SEPER || tok() == NEWLIN {
        // c:2384-2387 — `if (tok != SEPER) { ecstr(tokstr); num++; }`
        if tok() == STRING_LEX {
            ecstr(&tokstr().unwrap_or_default());
            num += 1;
        }
        // c:2388 — `zshlex();`
        zshlex();
    }
    // c:2390 — `return num;`
    num
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the loop-body tail shared by C's `par_for` / `par_while` /
/// `par_repeat` (the DOLOOP / INBRACE / short-form ladder at c:1170-1194),
/// factored out because all three Rust wordcode emitters need it.
/// Body dispatch shared by par_for / par_while / par_repeat.
/// Direct port of `Src/parse.c:1170-1194`.
fn par_loop_body_wordcode(cmplx: &mut i32, csh: bool, oecused: usize) {
    if tok() == DOLOOP {
        zshlex();
        // c:1172 — `par_save_list(cmplx);`
        par_save_list_wordcode(cmplx);
        if tok() != DONE {
            YYERRORV!(oecused);
        }
        set_incmdpos(false);
        zshlex();
    } else if tok() == INBRACE_TOK {
        zshlex();
        // c:1179 — `par_save_list(cmplx);`
        par_save_list_wordcode(cmplx);
        if tok() != OUTBRACE_TOK {
            YYERRORV!(oecused);
        }
        set_incmdpos(false);
        zshlex();
    } else if csh || isset(CSHJUNKIELOOPS) {
        // c:1185 — `par_save_list(cmplx);`
        par_save_list_wordcode(cmplx);
        if tok() != ZEND {
            YYERRORV!(oecused);
        }
        set_incmdpos(false);
        zshlex();
    } else if unset(SHORTLOOPS) {
        YYERRORV!(oecused);
    } else {
        // c:1193 — `par_save_list1(cmplx);`
        par_save_list1_wordcode(cmplx);
    }
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for C's SELECT routing: `par_cmd` sends both FOR and SELECT to `par_for`
/// (c:983-985), so this is a one-line alias onto `par_for_wordcode`.
/// `select` shares par_for body (c:983-985 routes SELECT to par_for).
pub fn par_select_wordcode(cmplx: &mut i32) {
    par_for_wordcode(cmplx);
}

/// Port of `par_case` from `Src/parse.c:1209` — C decl `par_case(int *cmplx)`. Rust fn `par_case_wordcode` is the wordcode-emitting variant.
pub fn par_case_wordcode(_cmplx: &mut i32) {
    // c:1211 — `int oecused = ecused, brflag, p, pp, palts, type, nalts;`
    let oecused = ECUSED.get() as usize;
    let brflag: bool;
    let p: usize;
    let mut pp: usize;
    let mut palts: usize;
    let mut r#type: wordcode;
    let mut nalts: u32;
    // c:1212 — `int ona, onc;`
    let ona: bool;
    let onc: i32;

    // c:1214 — `p = ecadd(0);`
    p = ecadd(0);

    // c:1216 — `incmdpos = 0;`
    set_incmdpos(false);
    // c:1217 — `zshlex();`
    zshlex();
    // c:1218-1219 — `if (tok != STRING) YYERRORV(oecused);`
    if tok() != STRING_LEX {
        YYERRORV!(oecused);
    }
    // c:1220 — `ecstr(tokstr);`
    ecstr(&tokstr().unwrap_or_default());

    // c:1222 — `incmdpos = 1;`
    set_incmdpos(true);
    // c:1223-1224 — `ona = noaliases; onc = nocorrect;`
    ona = noaliases();
    onc = nocorrect();
    // c:1225 — `noaliases = nocorrect = 1;`
    set_noaliases(true);
    set_nocorrect(1);
    // c:1226 — `zshlex();`
    zshlex();
    // c:1227-1228 — `while (tok == SEPER) zshlex();`
    while tok() == SEPER {
        zshlex();
    }
    // c:1229 — `if (!(tok == STRING && !strcmp(tokstr, "in")) && tok != INBRACE)`
    if !(tok() == STRING_LEX && tokstr().as_deref() == Some("in")) && tok() != INBRACE_TOK {
        // c:1231-1233 — restore noaliases/nocorrect + ERROR
        set_noaliases(ona);
        set_nocorrect(onc);
        YYERRORV!(oecused);
    }
    // c:1235 — `brflag = (tok == INBRACE);`
    brflag = tok() == INBRACE_TOK;
    // c:1236 — `incasepat = 1;`
    set_incasepat(1);
    // c:1237 — `incmdpos = 0;`
    set_incmdpos(false);
    // c:1238-1239 — `noaliases = ona; nocorrect = onc;`
    set_noaliases(ona);
    set_nocorrect(onc);
    // c:1240 — `zshlex();`
    zshlex();

    // c:1242 — `for (;;) {`
    'arms: loop {
        // c:1243 — `char *str;`
        let mut str: String;
        // c:1244 — `int skip_zshlex;`
        let skip_zshlex: bool;

        // c:1246-1247 — `while (tok == SEPER) zshlex();`
        while tok() == SEPER {
            zshlex();
        }
        // c:1248-1249 — `if (tok == OUTBRACE) break;`
        if tok() == OUTBRACE_TOK {
            break 'arms;
        }
        // c:1250-1251 — `if (tok == INPAR) zshlex();`
        if tok() == INPAR_TOK {
            zshlex();
        }
        // c:1252-1254 — `if (tok == BAR) { str = ""; skip_zshlex = 1; }`
        if tok() == BAR_TOK {
            str = String::new();
            skip_zshlex = true;
        } else {
            // c:1256-1257 — `if (tok != STRING) YYERRORV(oecused);`
            if tok() != STRING_LEX {
                YYERRORV!(oecused);
            }
            // c:1258-1259 — `if (!strcmp(tokstr, "esac")) break;`
            if tokstr().as_deref() == Some("esac") {
                break 'arms;
            }
            // c:1260 — `str = dupstring(tokstr);`
            str = tokstr().unwrap_or_default();
            // c:1261 — `skip_zshlex = 0;`
            skip_zshlex = false;
        }
        // c:1263 — `type = WC_CASE_OR;`
        r#type = WC_CASE_OR;
        // c:1264-1266 — `pp = ecadd(0); palts = ecadd(0); nalts = 0;`
        pp = ecadd(0);
        palts = ecadd(0);
        nalts = 0;
        // c:1300 — `incasepat = -1;`
        set_incasepat(-1);
        // c:1301 — `incmdpos = 1;`
        set_incmdpos(true);
        // c:1302-1303 — `if (!skip_zshlex) zshlex();`
        if !skip_zshlex {
            zshlex();
        }
        // c:1304 — `for (;;) {`
        loop {
            // c:1305-1313 — `if (tok == OUTPAR) { ecstr(str);
            //   ecadd(ecnpats++); nalts++; incasepat = 0;
            //   incmdpos = 1; zshlex(); break; }`
            if tok() == OUTPAR_TOK {
                ecstr(&str);
                let np = ECNPATS.with(|cc| {
                    let v = cc.get();
                    cc.set(v + 1);
                    v
                }) as u32;
                ecadd(np);
                nalts += 1;
                set_incasepat(0);
                set_incmdpos(true);
                zshlex();
                break;
            }
            // c:1314-1320 — `else if (tok == BAR) { ecstr(str);
            //   ecadd(ecnpats++); nalts++; incasepat = 1;
            //   incmdpos = 0; }`
            else if tok() == BAR_TOK {
                ecstr(&str);
                let np = ECNPATS.with(|cc| {
                    let v = cc.get();
                    cc.set(v + 1);
                    v
                }) as u32;
                ecadd(np);
                nalts += 1;
                set_incasepat(1);
                set_incmdpos(false);
            }
            // c:1321-1357 — else { ... `(...)` whole-pattern hack:
            // the lexer absorbed a complete `(...)` as one STRING
            // (str[0] == Inpar) and the current tok is already the
            // body's first token. Massage blanks around `|`/parens
            // at depth 1, validate balance, strip the surrounding
            // parens; the remainder IS the pattern. }
            else {
                use crate::ported::zsh_h::{Bar, Inpar, Outpar};
                if nalts == 0 && str.starts_with(Inpar) {
                    let meta = crate::ported::zsh_h::Meta as char;
                    let blank = |c: char| c.is_ascii() && crate::ported::ztype_h::iblank(c as u8);
                    let mut chars: Vec<char> = str.chars().collect();
                    // c:1323 — `int pct = 0, sl;`
                    let mut pct = 0i32;
                    let mut i = 0usize;
                    // c:1326-1344 — scan/massage loop. `s` ↔ `i`;
                    // chuck(p) ↔ chars.remove(idx).
                    let mut early_break = false;
                    while i < chars.len() {
                        if chars[i] == Inpar {
                            pct += 1;
                        }
                        // c:1329-1330 — `if (!pct) break;` (char past
                        // the balanced close → trailing garbage).
                        if pct == 0 {
                            early_break = true;
                            break;
                        }
                        if pct == 1 {
                            // c:1332-1334 — chuck blanks AFTER `|`/`(`.
                            if chars[i] == Bar || chars[i] == Inpar {
                                while i + 1 < chars.len() && blank(chars[i + 1]) {
                                    chars.remove(i + 1);
                                }
                            }
                            // c:1335-1338 — chuck blanks BEFORE `|`/`)`
                            // (not Meta-escaped blanks).
                            if chars[i] == Bar || chars[i] == Outpar {
                                while i >= 1
                                    && blank(chars[i - 1])
                                    && (i < 2 || chars[i - 2] != meta)
                                {
                                    chars.remove(i - 1);
                                    i -= 1;
                                }
                            }
                        }
                        if chars[i] == Outpar {
                            pct -= 1;
                        }
                        i += 1;
                    }
                    // c:1345-1346 — `if (*s || pct || s == str)
                    // YYERRORV(oecused);`
                    if early_break || pct != 0 || chars.is_empty() {
                        YYERRORV!(oecused);
                    }
                    // c:1347-1352 — strip surrounding `(...)`.
                    chars.pop();
                    chars.remove(0);
                    let stripped: String = chars.into_iter().collect();
                    // c:1353-1355 — `ecstr(str); ecadd(ecnpats++); nalts++;`
                    ecstr(&stripped);
                    let np = ECNPATS.with(|cc| {
                        let v = cc.get();
                        cc.set(v + 1);
                        v
                    }) as u32;
                    ecadd(np);
                    nalts += 1;
                    // c:1356 — `break;` — tok is already the body's
                    // first token; fall through to par_save_list.
                    break;
                }
                // c:1358 — `YYERRORV(oecused);`
                YYERRORV!(oecused);
            }

            // c:1359 — `zshlex();`
            zshlex();
            // c:1360-1377 — switch on next tok.
            match tok() {
                STRING_LEX => {
                    // c:1361-1365
                    str = tokstr().unwrap_or_default();
                    zshlex();
                }
                OUTPAR_TOK | BAR_TOK => {
                    // c:1367-1371 — empty string
                    str = String::new();
                }
                _ => {
                    // c:1374-1376 — `YYERRORV(oecused);`
                    YYERRORV!(oecused);
                }
            }
        }
        // c:1379 — `incasepat = 0;`
        set_incasepat(0);
        // c:1380 — `par_save_list(cmplx);`
        par_save_list_wordcode(_cmplx);
        // c:1381-1384 — terminator → arm type
        if tok() == SEMIAMP {
            r#type = WC_CASE_AND;
        } else if tok() == SEMIBAR {
            r#type = WC_CASE_TESTAND;
        }
        // c:1385 — `ecbuf[pp] = WCB_CASE(type, ecused - 1 - pp);`
        let used = ECUSED.get() as usize;
        ECBUF.with_borrow_mut(|b| {
            b[pp] = WCB_CASE(r#type, (used.saturating_sub(1 + pp)) as wordcode);
        });
        // c:1386 — `ecbuf[palts] = nalts;`
        ECBUF.with_borrow_mut(|b| {
            b[palts] = nalts;
        });
        // c:1387-1388 — terminator (ESAC w/o brace OR OUTBRACE w/ brace) → break
        if (tok() == ESAC && !brflag) || (tok() == OUTBRACE_TOK && brflag) {
            break 'arms;
        }
        // c:1389-1390 — `if (tok != DSEMI && tok != SEMIAMP && tok != SEMIBAR) YYERRORV;`
        if tok() != DSEMI && tok() != SEMIAMP && tok() != SEMIBAR {
            YYERRORV!(oecused);
        }
        // c:1391 — `incasepat = 1;`
        set_incasepat(1);
        // c:1392 — `incmdpos = 0;`
        set_incmdpos(false);
        // c:1393 — `zshlex();`
        zshlex();
    }
    // c:1395 — `incmdpos = 1;`
    set_incmdpos(true);
    // c:1396 — `incasepat = 0;`
    set_incasepat(0);
    // c:1397 — `zshlex();`
    zshlex();

    // c:1399 — `ecbuf[p] = WCB_CASE(WC_CASE_HEAD, ecused - 1 - p);`
    let used = ECUSED.get() as usize;
    ECBUF.with_borrow_mut(|b| {
        b[p] = WCB_CASE(WC_CASE_HEAD, (used.saturating_sub(1 + p)) as wordcode);
    });
}

/// Port of `par_if` from `Src/parse.c:1411` — C decl `par_if(int *cmplx)`. Rust fn `par_if_wordcode` is the wordcode-emitting variant.
pub fn par_if_wordcode(cmplx: &mut i32) {
    // c:1413 — `int oecused = ecused, p, pp, type, usebrace = 0;`
    let oecused = ECUSED.get() as usize;
    let p: usize;
    let mut pp: usize = 0;
    let mut r#type: wordcode = WC_IF_IF;
    let mut usebrace: i32 = 0;
    // c:1414 — `enum lextok xtok;`
    let mut xtok: lextok;
    // c:1415 — `unsigned char nc;`
    let nc: u8;
    let _ = nc;

    // c:1417 — `p = ecadd(0);`
    p = ecadd(0);

    // c:1419 — `for (;;) {`
    loop {
        // c:1420 — `xtok = tok;`
        xtok = tok();
        // c:1421 — `cmdpush(xtok == IF ? CS_IF : CS_ELIF);`
        cmdpush(if xtok == IF {
            CS_IF as u8
        } else {
            CS_ELIF as u8
        });
        // c:1422-1426 — `if (xtok == FI) { incmdpos = 0; zshlex(); break; }`
        if xtok == FI {
            set_incmdpos(false);
            zshlex();
            break;
        }
        // c:1427 — `zshlex();`
        zshlex();
        // c:1428-1429 — `if (xtok == ELSE) break;`
        if xtok == ELSE {
            break;
        }
        // c:1430-1431 — `while (tok == SEPER) zshlex();`
        while tok() == SEPER {
            zshlex();
        }
        // c:1432-1435 — `if (!(xtok == IF || xtok == ELIF)) { cmdpop(); YYERRORV; }`
        if !(xtok == IF || xtok == ELIF) {
            cmdpop();
            YYERRORV!(oecused);
        }
        // c:1436 — `pp = ecadd(0);`
        pp = ecadd(0);
        // c:1437 — `type = (xtok == IF ? WC_IF_IF : WC_IF_ELIF);`
        r#type = if xtok == IF { WC_IF_IF } else { WC_IF_ELIF };
        // c:1438 — `par_save_list(cmplx);` — condition body
        par_save_list_wordcode(cmplx);
        // c:1439 — `incmdpos = 1;`
        set_incmdpos(true);
        // c:1440-1443 — `if (tok == ENDINPUT) { cmdpop(); YYERRORV; }`
        if tok() == ENDINPUT {
            cmdpop();
            YYERRORV!(oecused);
        }
        // c:1444-1445 — `while (tok == SEPER) zshlex();`
        while tok() == SEPER {
            zshlex();
        }
        // c:1446 — `xtok = FI;` — pre-set so the post-loop check works
        xtok = FI;
        // c:1447 — `nc = cmdstack[cmdsp - 1] == CS_IF ? CS_IFTHEN : CS_ELIFTHEN;`
        // (Not tracked separately in zshrs cmdstack — derive from cur top
        // by reading CMDSTACK; for safety use CS_IFTHEN as default.)
        // We don't have a way to read top easily — match by tracking
        // whether we just pushed CS_IF or CS_ELIF.
        // For wordcode emission this only affects cmdstack debug output;
        // not the emitted wordcode. Use CS_IFTHEN.
        let nc_local: u8 = CS_IFTHEN as u8;
        if tok() == THEN {
            // c:1448-1456 — THEN branch
            // c:1449 — `usebrace = 0;`
            usebrace = 0;
            // c:1450 — `cmdpop();`
            cmdpop();
            // c:1451 — `cmdpush(nc);`
            cmdpush(nc_local);
            // c:1452 — `zshlex();`
            zshlex();
            // c:1453 — `par_save_list(cmplx);` — then body
            par_save_list_wordcode(cmplx);
            // c:1454 — `ecbuf[pp] = WCB_IF(type, ecused - 1 - pp);`
            let used = ECUSED.get() as usize;
            ECBUF.with_borrow_mut(|b| {
                b[pp] = WCB_IF(r#type, (used.saturating_sub(1 + pp)) as wordcode);
            });
            // c:1455 — `incmdpos = 1;`
            set_incmdpos(true);
            // c:1456 — `cmdpop();`
            cmdpop();
        } else if tok() == INBRACE_TOK {
            // c:1457-1473 — INBRACE branch
            // c:1458 — `usebrace = 1;`
            usebrace = 1;
            // c:1459 — `cmdpop();`
            cmdpop();
            // c:1460 — `cmdpush(nc);`
            cmdpush(nc_local);
            // c:1461 — `zshlex();`
            zshlex();
            // c:1462 — `par_save_list(cmplx);`
            par_save_list_wordcode(cmplx);
            // c:1463-1466 — `if (tok != OUTBRACE) { cmdpop(); YYERRORV; }`
            if tok() != OUTBRACE_TOK {
                cmdpop();
                YYERRORV!(oecused);
            }
            // c:1467 — `ecbuf[pp] = WCB_IF(type, ecused - 1 - pp);`
            let used = ECUSED.get() as usize;
            ECBUF.with_borrow_mut(|b| {
                b[pp] = WCB_IF(r#type, (used.saturating_sub(1 + pp)) as wordcode);
            });
            // c:1469 — `zshlex();`
            zshlex();
            // c:1470 — `incmdpos = 1;`
            set_incmdpos(true);
            // c:1471-1472 — `if (tok == SEPER) break;`
            if tok() == SEPER {
                break;
            }
            // c:1473 — `cmdpop();`
            cmdpop();
        } else if unset(SHORTLOOPS) {
            // c:1474-1476 — `cmdpop(); YYERRORV;`
            cmdpop();
            YYERRORV!(oecused);
        } else {
            // c:1477-1484 — short loop form
            // c:1478 — `cmdpop();`
            cmdpop();
            // c:1479 — `cmdpush(nc);`
            cmdpush(nc_local);
            // c:1480 — `par_save_list1(cmplx);`
            par_save_list1_wordcode(cmplx);
            // c:1481 — `ecbuf[pp] = WCB_IF(type, ecused - 1 - pp);`
            let used = ECUSED.get() as usize;
            ECBUF.with_borrow_mut(|b| {
                b[pp] = WCB_IF(r#type, (used.saturating_sub(1 + pp)) as wordcode);
            });
            // c:1482 — `incmdpos = 1;`
            set_incmdpos(true);
            // c:1483 — `break;`
            break;
        }
    }
    // c:1486 — `cmdpop();`
    cmdpop();
    // c:1487 — `if (xtok == ELSE || tok == ELSE) {`
    if xtok == ELSE || tok() == ELSE {
        // c:1488 — `pp = ecadd(0);`
        pp = ecadd(0);
        // c:1489 — `cmdpush(CS_ELSE);`
        cmdpush(CS_ELSE as u8);
        // c:1490-1491 — `while (tok == SEPER) zshlex();`
        while tok() == SEPER {
            zshlex();
        }
        // c:1492-1498 — `if (tok == INBRACE && usebrace) { ... } else { ... }`
        if tok() == INBRACE_TOK && usebrace != 0 {
            // c:1493 — `zshlex();`
            zshlex();
            // c:1494 — `par_save_list(cmplx);`
            par_save_list_wordcode(cmplx);
            // c:1495-1498 — `if (tok != OUTBRACE) { cmdpop(); YYERRORV; }`
            if tok() != OUTBRACE_TOK {
                cmdpop();
                YYERRORV!(oecused);
            }
        } else {
            // c:1500 — `par_save_list(cmplx);`
            par_save_list_wordcode(cmplx);
            // c:1501-1504 — `if (tok != FI) { cmdpop(); YYERRORV; }`
            if tok() != FI {
                cmdpop();
                YYERRORV!(oecused);
            }
        }
        // c:1506 — `incmdpos = 0;`
        set_incmdpos(false);
        // c:1507 — `ecbuf[pp] = WCB_IF(WC_IF_ELSE, ecused - 1 - pp);`
        let used = ECUSED.get() as usize;
        ECBUF.with_borrow_mut(|b| {
            b[pp] = WCB_IF(WC_IF_ELSE, (used.saturating_sub(1 + pp)) as wordcode);
        });
        // c:1508 — `zshlex();`
        zshlex();
        // c:1509 — `cmdpop();`
        cmdpop();
    }
    // c:1511 — `ecbuf[p] = WCB_IF(WC_IF_HEAD, ecused - 1 - p);`
    let used = ECUSED.get() as usize;
    ECBUF.with_borrow_mut(|b| {
        b[p] = WCB_IF(WC_IF_HEAD, (used.saturating_sub(1 + p)) as wordcode);
    });
}

/// Port of `par_while` from `Src/parse.c:1521` — C decl `par_while(int *cmplx)`. Rust fn `par_while_wordcode` is the wordcode-emitting variant.
pub fn par_while_wordcode(cmplx: &mut i32) {
    // c:1523 — `int oecused = ecused, p;`
    let oecused = ECUSED.get() as usize;
    let p: usize;
    // c:1524 — `int type = (tok == UNTIL ? WC_WHILE_UNTIL : WC_WHILE_WHILE);`
    let r#type: wordcode = if tok() == UNTIL {
        WC_WHILE_UNTIL
    } else {
        WC_WHILE_WHILE
    };

    // c:1526 — `p = ecadd(0);`
    p = ecadd(0);
    // c:1527 — `zshlex();`
    zshlex();
    // c:1528 — `par_save_list(cmplx);` — condition.
    par_save_list_wordcode(cmplx);
    // c:1529 — `incmdpos = 1;`
    set_incmdpos(true);
    // c:1530-1531 — `while (tok == SEPER) zshlex();`
    while tok() == SEPER {
        zshlex();
    }
    // c:1532-1545 — body dispatch (inlined in C; we factor via
    // par_loop_body_wordcode since for/while/repeat share this
    // identical block).
    if tok() == DOLOOP {
        // c:1533 — `zshlex();`
        zshlex();
        // c:1534 — `par_save_list(cmplx);`
        par_save_list_wordcode(cmplx);
        // c:1535-1536 — `if (tok != DONE) YYERRORV(oecused);`
        if tok() != DONE {
            YYERRORV!(oecused);
        }
        // c:1537 — `incmdpos = 0;`
        set_incmdpos(false);
        // c:1538 — `zshlex();`
        zshlex();
    } else if tok() == INBRACE_TOK {
        // c:1540 — `zshlex();`
        zshlex();
        // c:1541 — `par_save_list(cmplx);`
        par_save_list_wordcode(cmplx);
        // c:1542-1543 — `if (tok != OUTBRACE) YYERRORV(oecused);`
        if tok() != OUTBRACE_TOK {
            YYERRORV!(oecused);
        }
        // c:1544 — `incmdpos = 0;`
        set_incmdpos(false);
        // c:1545 — `zshlex();`
        zshlex();
    } else if isset(CSHJUNKIELOOPS) {
        // c:1546-1550
        par_save_list_wordcode(cmplx);
        if tok() != ZEND {
            YYERRORV!(oecused);
        }
        zshlex();
    } else if unset(SHORTLOOPS) {
        // c:1551-1552 — `YYERRORV(oecused);`
        YYERRORV!(oecused);
    } else {
        // c:1554 — `par_save_list1(cmplx);`
        par_save_list1_wordcode(cmplx);
    }

    // c:1556 — `ecbuf[p] = WCB_WHILE(type, ecused - 1 - p);`
    let used = ECUSED.get() as usize;
    ECBUF.with_borrow_mut(|b| {
        b[p] = WCB_WHILE(r#type, (used.saturating_sub(1 + p)) as wordcode);
    });
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for C's UNTIL routing: `par_cmd` sends both WHILE and UNTIL to `par_while`
/// (c:990-992), so this is a one-line alias onto `par_while_wordcode`.
/// `until` shares par_while body — tok==UNTIL flips the type.
pub fn par_until_wordcode(cmplx: &mut i32) {
    par_while_wordcode(cmplx);
}

/// Port of `par_repeat` from `Src/parse.c:1565` — C decl `par_repeat(int *cmplx)`. Rust fn `par_repeat_wordcode` is the wordcode-emitting variant.
pub fn par_repeat_wordcode(cmplx: &mut i32) {
    // c:1567 — `/* ### what to do about inrepeat_ here? */`
    // c:1568 — `int oecused = ecused, p;`
    let oecused = ECUSED.get() as usize;
    let p: usize;

    // c:1570 — `p = ecadd(0);`
    p = ecadd(0);

    // c:1572 — `incmdpos = 0;`
    set_incmdpos(false);
    // c:1573 — `zshlex();`
    zshlex();
    // c:1574-1575 — `if (tok != STRING) YYERRORV(oecused);`
    if tok() != STRING_LEX {
        YYERRORV!(oecused);
    }
    // c:1576 — `ecstr(tokstr);`
    ecstr(&tokstr().unwrap_or_default());
    // c:1577 — `incmdpos = 1;`
    set_incmdpos(true);
    // c:1578 — `zshlex();`
    zshlex();
    // c:1579-1580 — `while (tok == SEPER) zshlex();`
    while tok() == SEPER {
        zshlex();
    }
    // c:1581-1604 — body dispatch (inlined here matching C exactly).
    if tok() == DOLOOP {
        // c:1582-1587
        zshlex();
        par_save_list_wordcode(cmplx);
        if tok() != DONE {
            YYERRORV!(oecused);
        }
        set_incmdpos(false);
        zshlex();
    } else if tok() == INBRACE_TOK {
        // c:1589-1594
        zshlex();
        par_save_list_wordcode(cmplx);
        if tok() != OUTBRACE_TOK {
            YYERRORV!(oecused);
        }
        set_incmdpos(false);
        zshlex();
    } else if isset(CSHJUNKIELOOPS) {
        // c:1596-1599
        par_save_list_wordcode(cmplx);
        if tok() != ZEND {
            YYERRORV!(oecused);
        }
        zshlex();
    } else if unset(SHORTLOOPS) && unset(SHORTREPEAT) {
        // c:1601-1602 — par_repeat needs BOTH SHORTLOOPS and SHORTREPEAT
        // unset to refuse short form (more permissive than par_while).
        YYERRORV!(oecused);
    } else {
        // c:1604 — `par_save_list1(cmplx);`
        par_save_list1_wordcode(cmplx);
    }

    // c:1606 — `ecbuf[p] = WCB_REPEAT(ecused - 1 - p);`
    let used = ECUSED.get() as usize;
    ECBUF.with_borrow_mut(|b| {
        b[p] = WCB_REPEAT((used.saturating_sub(1 + p)) as wordcode);
    });
}

/// Port of `par_funcdef` from `Src/parse.c:1672` — C decl `par_funcdef(int *cmplx)`. Rust fn `par_funcdef_wordcode` is the wordcode-emitting variant.
///
/// The `function NAME { ... }` form. Emits a WCB_FUNCDEF header
/// followed by a names-count slot, the names themselves, four
/// metadata slots (string-area start, string-area length, npats,
/// do_tracing), then the body wordcode, then WCB_END.
///
/// Critical: saves/resets `ecnpats` + `ecssub` + `ecsoffs` around
/// the body parse so per-function pattern counts don't leak into
/// the enclosing scope's `ecnpats` accumulator (parse.c:1723-1758).
pub fn par_funcdef_wordcode(cmplx: &mut i32) {
    // c:1674 — `int oecused = ecused, num = 0, onp, p, c = 0;`
    let oecused = ECUSED.get() as usize;
    let mut num: i32 = 0;
    let onp: i32;
    let p: usize;
    let mut c: i32 = 0;
    // c:1675 — `int so, oecssub = ecssub;`
    let so: i32;
    let oecssub = ECSSUB.get();
    // c:1676 — `zlong oldlineno = lineno;`
    let oldlineno = lineno();
    // c:1677 — `int do_tracing = 0;`
    let mut do_tracing: i32 = 0;

    // c:1679 — `lineno = 0;`
    set_lineno(0);
    // c:1680 — `nocorrect = 1;`
    set_nocorrect(1);
    // c:1681 — `incmdpos = 0;`
    set_incmdpos(false);
    // c:1682 — `zshlex();`
    zshlex();

    // c:1684 — `p = ecadd(0);`
    p = ecadd(0);
    // c:1685 — `ecadd(0); /* p + 1 */`
    let p1 = ecadd(0);

    // c:1687-1699 — `Consume an initial (-T), (--), or (-T --).`
    // c:1690 — `if (tok == STRING && tokstr[0] == Dash) {`
    if tok() == STRING_LEX {
        let s = tokstr().unwrap_or_default();
        let bytes = s.as_bytes();
        // C: `tokstr[0] == Dash`. The Dash token is U+e19B (crate::token_char),
        // `0xee 0x82 0x9b` in UTF-8; the plain char `'-'` is 0x2d.
        // Match either form.
        let first_is_dash = bytes.starts_with(&[0xee, 0x86, 0x9b])
            || (bytes.len() >= 1 && bytes[0] == b'-');
        if first_is_dash {
            // c:1691-1694 — `if (tokstr[1] == 'T' && !tokstr[2]) { ++do_tracing; zshlex(); }`
            // After the leading dash byte(s), check remaining bytes.
            let after_dash = if bytes.starts_with(&[0xee, 0x86, 0x9b]) {
                &bytes[3..]
            } else {
                &bytes[1..]
            };
            if after_dash.len() == 1 && after_dash[0] == b'T' {
                do_tracing += 1;
                zshlex();
            }
            // c:1695-1698 — `if (tok == STRING && tokstr[0] == Dash &&
            //                  tokstr[1] == Dash && !tokstr[2]) zshlex();`
            if tok() == STRING_LEX {
                let s2 = tokstr().unwrap_or_default();
                let b2 = s2.as_bytes();
                let mut idx = 0;
                let mut dashes = 0;
                while idx < b2.len() && dashes < 2 {
                    if b2[idx..].starts_with(&[0xee, 0x86, 0x9b]) {
                        idx += 3;
                        dashes += 1;
                    } else if b2[idx] == b'-' {
                        idx += 1;
                        dashes += 1;
                    } else {
                        break;
                    }
                }
                if dashes == 2 && idx == b2.len() {
                    zshlex();
                }
            }
        }
    }

    // c:1701-1709 — names loop.
    // `while (tok == STRING) { if ((*tokstr == Inbrace || *tokstr == '{')
    //   && !tokstr[1]) { tok = INBRACE; break; } ecstr(tokstr); num++; zshlex(); }`
    while tok() == STRING_LEX {
        let s = tokstr().unwrap_or_default();
        let bytes = s.as_bytes();
        // First char tests for the Inbrace token (U+e18F, UTF-8 `0xee 0x82 0x8f`) or `{`,
        // and length-1 check (`!tokstr[1]`).
        let is_inbrace_only = (bytes.len() == 1 && bytes[0] == b'{')
            || (bytes == [0xee, 0x86, 0x8f]);
        if is_inbrace_only {
            set_tok(INBRACE_TOK);
            break;
        }
        ecstr(&s);
        num += 1;
        zshlex();
    }

    // c:1711-1714 — four metadata placeholder slots.
    let m2 = ecadd(0);
    let m3 = ecadd(0);
    let m4 = ecadd(0);
    let m5 = ecadd(0);

    // c:1716 — `nocorrect = 0;`
    set_nocorrect(0);
    // c:1717 — `incmdpos = 1;`
    set_incmdpos(true);
    // c:1718-1719 — `if (tok == INOUTPAR) zshlex();`
    if tok() == INOUTPAR {
        zshlex();
    }
    // c:1720-1721 — `while (tok == SEPER) zshlex();`
    while tok() == SEPER {
        zshlex();
    }

    // c:1723 — `ecnfunc++;`
    ECNFUNC.set(ECNFUNC.get() + 1);
    // c:1724 — `ecssub = so = ecsoffs;`
    so = ECSOFFS.get();
    ECSSUB.set(so);
    // c:1725 — `onp = ecnpats;`
    onp = ECNPATS.with(|cc| cc.get());
    // c:1726 — `ecnpats = 0;`
    ECNPATS.with(|cc| cc.set(0));

    // c:1728 — `if (tok == INBRACE) {`
    if tok() == INBRACE_TOK {
        // c:1729 — `zshlex();`
        zshlex();
        // c:1730 — `par_list(&c);`
        par_list_wordcode(&mut c);
        // c:1731-1736 — `if (tok != OUTBRACE) { lineno += oldlineno; ... }`
        if tok() != OUTBRACE_TOK {
            set_lineno(lineno() + oldlineno);
            ECNPATS.with(|cc| cc.set(onp));
            ECSSUB.set(oecssub);
            YYERRORV!(oecused);
        }
        // c:1737-1740 — `if (num == 0) { incmdpos = 0; }`
        if num == 0 {
            set_incmdpos(false);
        }
        // c:1741 — `zshlex();`
        zshlex();
    } else if unset(SHORTLOOPS) {
        // c:1742-1746 — `lineno += oldlineno; ecnpats = onp; ecssub = oecssub; YYERRORV`
        set_lineno(lineno() + oldlineno);
        ECNPATS.with(|cc| cc.set(onp));
        ECSSUB.set(oecssub);
        YYERRORV!(oecused);
    } else {
        // c:1748 — `par_list1(&c);`
        par_list1_wordcode(&mut c);
    }

    // c:1750 — `ecadd(WCB_END());`
    ecadd(WCB_END());
    // c:1751-1754 — fill the 4 metadata slots
    let cur_sofs = ECSOFFS.get();
    let body_npats = ECNPATS.with(|cc| cc.get());
    ECBUF.with_borrow_mut(|b| {
        b[m2] = (so - oecssub) as wordcode;
        b[m3] = (cur_sofs - so) as wordcode;
        b[m4] = body_npats as wordcode;
        b[m5] = do_tracing as wordcode;
    });
    // c:1755 — `ecbuf[p + 1] = num;`
    ECBUF.with_borrow_mut(|b| {
        b[p1] = num as wordcode;
    });

    // c:1757 — `ecnpats = onp;`
    ECNPATS.with(|cc| cc.set(onp));
    // c:1758 — `ecssub = oecssub;`
    ECSSUB.set(oecssub);
    // c:1759 — `ecnfunc++;`
    ECNFUNC.set(ECNFUNC.get() + 1);

    // c:1761 — `ecbuf[p] = WCB_FUNCDEF(ecused - 1 - p);`
    let used = ECUSED.get() as usize;
    ECBUF.with_borrow_mut(|b| {
        b[p] = WCB_FUNCDEF((used.saturating_sub(1 + p)) as wordcode);
    });

    // c:1763-1777 — anonymous-function trailing args (num == 0 case).
    if num == 0 {
        // c:1766 — `int parg = ecadd(0);`
        let parg = ecadd(0);
        // c:1767 — `ecadd(0);`
        ecadd(0);
        // c:1768-1772 — `while (tok == STRING) { ecstr(tokstr); num++; zshlex(); }`
        while tok() == STRING_LEX {
            ecstr(&tokstr().unwrap_or_default());
            num += 1;
            zshlex();
        }
        // c:1773-1774 — `if (num > 0) *cmplx = 1;`
        if num > 0 {
            *cmplx = 1;
        }
        // c:1775 — `ecbuf[parg] = ecused - parg;`
        // c:1776 — `ecbuf[parg+1] = num;`
        let used2 = ECUSED.get() as usize;
        ECBUF.with_borrow_mut(|b| {
            b[parg] = (used2 - parg) as wordcode;
            b[parg + 1] = num as wordcode;
        });
    }
    // c:1778 — `lineno += oldlineno;`
    set_lineno(lineno() + oldlineno);
}

/// Size of `struct fdhead` in `wordcode` (u32) units. Used by all
/// the header-walk macros below.
pub const FDHEAD_WORDS: usize = size_of::<fdhead>() / 4;

/// Port of `par_subsh` from `Src/parse.c:1619` — C decl `par_subsh(int *cmplx, int zsh_construct)`. Rust fn `par_subsh_wordcode` is the wordcode-emitting variant; `zsh_construct` selects the `{...}` (cursh) shape as in C.
/// `Src/parse.c:1619-1665`. Handles both `(...)` subshell and
/// `{...}` brace group (cursh) plus optional `always { ... }`
/// trailing block. C uses a single function with `zsh_construct=1`
/// for `{...}` and 0 for `(...)`.
pub fn par_subsh_wordcode(cmplx: &mut i32, zsh_construct: i32) {
    // c:1621 — `enum lextok otok = tok;`
    let otok = tok();
    // c:1622 — `int oecused = ecused, p, pp;`
    let oecused = ECUSED.get() as usize;
    let p: usize;
    let pp: usize;

    // c:1624 — `p = ecadd(0);`
    p = ecadd(0);
    // c:1625 — `/* Extra word only needed for always block */`
    // c:1626 — `pp = ecadd(0);`
    pp = ecadd(0);
    // c:1627 — `zshlex();`
    zshlex();
    // c:1628 — `par_list(cmplx);`
    par_list_wordcode(cmplx);
    // c:1629 — `ecadd(WCB_END());`
    ecadd(WCB_END());
    // c:1630-1631 — `if (tok != ((otok == INPAR) ? OUTPAR : OUTBRACE))
    // YYERRORV(oecused);`
    if tok()
        != (if otok == INPAR_TOK {
            OUTPAR_TOK
        } else {
            OUTBRACE_TOK
        })
    {
        YYERRORV!(oecused);
    }
    // c:1632 — `incmdpos = !zsh_construct;`
    set_incmdpos(zsh_construct == 0);
    // c:1633 — `zshlex();`
    zshlex();

    // c:1635 — `/* Optional always block. No intervening SEPERs allowed. */`
    // c:1636 — `if (otok == INBRACE && tok == STRING && !strcmp(tokstr, "always")) {`
    if otok == INBRACE_TOK && tok() == STRING_LEX && tokstr().as_deref() == Some("always") {
        // c:1637 — `ecbuf[pp] = WCB_TRY(ecused - 1 - pp);`
        let used = ECUSED.get() as usize;
        ECBUF.with_borrow_mut(|b| {
            b[pp] = WCB_TRY((used.saturating_sub(1 + pp)) as wordcode);
        });
        // c:1638 — `incmdpos = 1;`
        set_incmdpos(true);
        // c:1639-1641 — `do { zshlex(); } while (tok == SEPER);`
        loop {
            zshlex();
            if tok() != SEPER {
                break;
            }
        }

        // c:1643-1644 — `if (tok != INBRACE) YYERRORV(oecused);`
        if tok() != INBRACE_TOK {
            YYERRORV!(oecused);
        }
        // c:1645 — `cmdpop();`
        cmdpop();
        // c:1646 — `cmdpush(CS_ALWAYS);`
        cmdpush(CS_ALWAYS as u8);

        // c:1648 — `zshlex();`
        zshlex();
        // c:1649 — `par_save_list(cmplx);`
        par_save_list_wordcode(cmplx);
        // c:1650-1651 — `while (tok == SEPER) zshlex();`
        while tok() == SEPER {
            zshlex();
        }

        // c:1653 — `incmdpos = 1;`
        set_incmdpos(true);

        // c:1655-1656 — `if (tok != OUTBRACE) YYERRORV(oecused);`
        if tok() != OUTBRACE_TOK {
            YYERRORV!(oecused);
        }
        // c:1657 — `zshlex();`
        zshlex();
        // c:1658 — `ecbuf[p] = WCB_TRY(ecused - 1 - p);`
        let used = ECUSED.get() as usize;
        ECBUF.with_borrow_mut(|b| {
            b[p] = WCB_TRY((used.saturating_sub(1 + p)) as wordcode);
        });
    } else {
        // c:1660-1661 — `ecbuf[p] = (otok == INPAR ? WCB_SUBSH(...) : WCB_CURSH(...));`
        let used = ECUSED.get() as usize;
        let off = used.saturating_sub(1 + p);
        ECBUF.with_borrow_mut(|b| {
            b[p] = if otok == INPAR_TOK {
                WCB_SUBSH(off as wordcode)
            } else {
                WCB_CURSH(off as wordcode)
            };
        });
    }
}

/// Port of `par_time()` from `Src/parse.c:1787` — C signature `par_time(void)`. `time PIPE`
/// emits WCB_TIMED(WC_TIMED_PIPE) + the sublist code; bare `time`
/// with no pipeline emits WCB_TIMED(WC_TIMED_EMPTY).
pub fn par_time_wordcode() {
    // c:1791 — `zshlex();`
    zshlex();
    // c:1793-1794 — `p = ecadd(0); ecadd(0);`
    let p = ecadd(0);
    ecadd(0);
    // c:1795 — `if ((f = par_sublist2(&c)) < 0)`
    let mut c = 0i32;
    let f = par_sublist2(&mut c);
    match f {
        Some(flags) => {
            // c:1799 — `ecbuf[p] = WCB_TIMED(WC_TIMED_PIPE);`
            ECBUF.with_borrow_mut(|b| {
                if p < b.len() {
                    b[p] = WCB_TIMED(WC_TIMED_PIPE);
                }
            });
            // c:1800 — `set_sublist_code(p+1, WC_SUBLIST_END, f,
            // ecused-2-p, c);`
            let used = ECUSED.get() as usize;
            let skip = used.saturating_sub(2 + p) as i32;
            set_sublist_code(p + 1, WC_SUBLIST_END as i32, flags, skip, c != 0);
        }
        None => {
            // c:1796-1798 — `ecused--; ecbuf[p] = WCB_TIMED(WC_TIMED_EMPTY);`
            ECUSED.set((ECUSED.get() - 1).max(0));
            ECBUF.with_borrow_mut(|b| {
                if p < b.len() {
                    b[p] = WCB_TIMED(WC_TIMED_EMPTY);
                }
            });
        }
    }
}

/// Port of `par_dinbrack()` from `Src/parse.c:1810` — C signature `par_dinbrack(void)`. Wraps
/// `par_cond` (the cond-expression emitter at parse.c:2409) with
/// the `[[ ... ]]` framing: incond/incmdpos toggles + DOUTBRACK
/// expectation.
pub fn par_cond_wordcode() {
    let oecused = ECUSED.get();
    // c:1814 — `incond = 1;`
    set_incond(1);
    // c:1815 — `incmdpos = 0;`
    set_incmdpos(false);
    // c:1816 — `zshlex();` past `[[`.
    zshlex();
    // c:1817 — `par_cond();` — call the no-skip cond-expression
    // entry that EMITS WORDCODE (par_cond_top → par_cond_1 →
    // par_cond_2 → par_cond_double/triple/multi). NOT the AST
    // `par_cond` at parse.rs:4644 which is a misnamed `par_dinbrack`
    // that skips `[[` AND `]]` and returns a ZshCommand AST node
    // instead of pushing WC_COND opcodes. NOT `parse_cond_expr`
    // either — that's also AST-only, returning ZshCond. With
    // `parse_cond_expr` here, every `[[ ... ]]` test produced ZERO
    // wordcode payload and parity dropped ~148 words on /etc/zshrc.
    let _ = par_cond_top();
    // c:1818-1819 — `if (tok != DOUTBRACK) YYERRORV(oecused);`
    if tok() != DOUTBRACK {
        let _ = oecused;
        YYERRORV!(oecused);
    }
    // c:1820 — `incond = 0;`
    set_incond(0);
    // c:1821 — `incmdpos = 1;`
    set_incmdpos(true);
    // c:1822 — `zshlex();` past `]]`.
    zshlex();
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the `case DINPAR:` arm of `par_cmd` (c:1031-1035: `ecadd(WCB_ARITH());
/// ecstr(tokstr); zshlex();`), which C inlines rather than giving it a
/// function.
/// Port of the `case DINPAR:` arm of `par_cmd` from
/// `Src/parse.c:1031-1034`:
/// ```c
/// ecadd(WCB_ARITH());
/// ecstr(tokstr);
/// zshlex();
/// ```
/// `(( EXPR ))` arithmetic at command position — emits the ARITH
/// opcode followed by the interned EXPR string, then advances past
/// the DINPAR token (which already carries the body text).
pub fn par_arith_wordcode() {
    // c:1032 — `ecadd(WCB_ARITH());`
    ecadd(WCB_ARITH());
    // c:1033 — `ecstr(tokstr);` — interns the expression string and
    // appends its strcode index to the wordcode buffer.
    let expr = tokstr().unwrap_or_default();
    ecstr(&expr);
    // c:1034 — `zshlex();`
    zshlex();
}

/// Port of `par_simple` from `Src/parse.c:1836` — C decl `par_simple(int *cmplx, int nr)`. Rust fn `par_simple_wordcode` is the wordcode-emitting variant.
/// Emits WC_SIMPLE + word count +
/// interned string offsets. Returns `0` when nothing was emitted,
/// otherwise `1 + (number of code words consumed by redirections)`.
/// The full C body handles assignments (ENVSTRING/ENVARRAY),
/// inline `{var}>file` brace-FDs, prefix modifiers (NOCORRECT etc),
/// and `name() { body }` funcdef detection — those paths are
/// progressively wired into the AST parser; this wordcode-emitter
/// covers the simple `cmd args...` case + interleaved redirs.
pub fn par_simple_wordcode(cmplx: &mut i32, mut nr: i32) -> i32 {
    // c:1838-1841 — `int oecused = ecused, isnull = 1, r, argc = 0,
    //   p, isfunc = 0, sr = 0;`
    //   `int c = *cmplx, nrediradd, assignments = 0, ppost = 0,
    //   is_typeset = 0;`
    // c is the SAVED initial cmplx so INOUTPAR can restore via
    // `*cmplx = c;` at c:2070.
    let oecused = ECUSED.get() as usize;
    let c_saved = *cmplx;
    let mut isnull = true;
    let mut argc: u32 = 0;
    let mut sr: i32 = 0;
    let mut assignments = false;
    let mut isfunc = false;

    // c:1843 — `r = ecused;` — saves the offset where redirs get
    // INSERTED (via ecispace). Each redir shifts later words DOWN
    // by ncodes, so the SIMPLE placeholder at `p` (set later) must
    // also bump by ncodes when a redir lands. C uses `&r` to pass
    // the cursor by reference; Rust uses a mutable local + manual
    // bumps after each par_redir_wordcode call.
    let mut r: usize = ECUSED.get() as usize;

    // c:1844-1919 — pre-cmd loop: NOCORRECT, ENVSTRING (scalar
    // assigns), ENVARRAY (array assigns), IS_REDIROP. Loops until
    // a non-assignment token is seen.
    loop {
        match tok() {
            NOCORRECT => {
                // c:1846-1849
                *cmplx = 1;
                set_nocorrect(1);
            }
            ENVSTRING => {
                // c:1848-1898 — scalar assignment `name=value` or
                // `name+=value`. Emits WCB_ASSIGN(SCALAR, NEW|INC, 0)
                // followed by ecstr(name), ecstr(value).
                let raw = tokstr().unwrap_or_default();
                // Find first of Inbrack / '=' / '+' (the C scan at
                // c:1851-1853). Inside Inbrack we skipparens — i.e.
                // skip `name[...]` index, then continue.
                // c:1851-1853 — `for (ptr = tokstr; *ptr && *ptr != Inbrack
                // && *ptr != '=' && *ptr != '+'; ptr++); if (*ptr == Inbrack)
                // skipparens(Inbrack, Outbrack, &ptr);`. Walk to the first
                // `[`/`=`/`+`/Equals-token, then if we landed on `[`, skip
                // the balanced `name[index]` pair via skipparens.
                let bytes: Vec<char> = raw.chars().collect();
                let raw_str: String = bytes.iter().collect();
                let mut idx = 0usize;
                while idx < bytes.len() {
                    let ch = bytes[idx];
                    if ch == '\u{e191}' /* Inbrack */
                        || ch == '=' || ch == '+' || ch == '\u{e18d}'
                    /* Equals */
                    {
                        break;
                    }
                    idx += 1;
                }
                if idx < bytes.len() && bytes[idx] == '\u{e191}'
                /* Inbrack */
                {
                    // c:1855 — `skipparens(Inbrack, Outbrack, &ptr);`.
                    let byte_off: usize = bytes[..idx].iter().map(|c| c.len_utf8()).sum();
                    let mut cursor: &str = &raw_str[byte_off..];
                    let _ = crate::ported::utils::skipparens('\u{e191}', '\u{e192}', &mut cursor);
                    let consumed = raw_str.len() - byte_off - cursor.len();
                    let advance_chars = raw_str[byte_off..byte_off + consumed].chars().count();
                    idx += advance_chars;
                    // Continue scanning for `=` / `+` after the `]`.
                    while idx < bytes.len() {
                        let ch = bytes[idx];
                        if ch == '=' || ch == '+' || ch == '\u{e18d}' {
                            break;
                        }
                        idx += 1;
                    }
                }
                let is_inc = idx < bytes.len() && bytes[idx] == '+';
                // c:1856-1858 — `if (*ptr == '+') { *ptr++ = '\0';
                // ecadd(WCB_ASSIGN(SCALAR, INC, 0)); } else WCB_NEW`
                // C nulls the `+` AT THAT POSITION then advances ptr.
                // `name` is bytes BEFORE the `+`, NOT including it.
                let name_end = idx;
                if is_inc {
                    idx += 1;
                }
                let flag = if is_inc { WC_ASSIGN_INC } else { WC_ASSIGN_NEW };
                ecadd(WCB_ASSIGN(WC_ASSIGN_SCALAR, flag, 0));
                // c:1860 — `if (*ptr == '=') { *ptr = '\0'; str = ptr + 1; }
                //          else equalsplit(tokstr, &str);`
                let name: String = bytes[..name_end].iter().collect();
                let str_off = if idx < bytes.len() && (bytes[idx] == '=' || bytes[idx] == '\u{e18d}')
                {
                    idx + 1
                } else {
                    idx
                };
                let value: String = bytes[str_off..].iter().collect();
                // c:1866-1877 — scan value for `=(`/`<(`/`>(` (proc
                // subst); if found, bump cmplx (suppresses Z_SIMPLE).
                let vbytes: Vec<char> = value.chars().collect();
                for (i, ch) in vbytes.iter().enumerate() {
                    if i + 1 < vbytes.len() && vbytes[i + 1] == '\u{e188}'
                    /* Inpar */
                    {
                        if *ch == '\u{e18d}' /* Equals */
                            || *ch == '\u{e194}' /* Inang */
                            || *ch == '\u{e196}'
                        /* OutangProc */
                        {
                            *cmplx = 1;
                            break;
                        }
                    }
                }
                // c:1856-1865 — `name` is NUL-terminated inside tokstr.
                // !!! RUST-ONLY !!! — write the cut through to zshlextext (see the
                // leading-assignment loop in par_simple).
                crate::ported::lex::LEX_ZSHLEXTEXT.with_borrow_mut(|t| {
                    if let Some(text) = t.as_mut().filter(|text| text.starts_with(name.as_str())) {
                        text.truncate(name.len());
                    }
                });
                ecstr(&name);
                ecstr(&value);
                isnull = false;
                assignments = true;
            }
            ENVARRAY => {
                // c:1883-1908 — array assignment `name=( ... )` in the
                // pre-cmd loop (no `typeset`-style typeset_force flag).
                // c:1884 — `int oldcmdpos = incmdpos, n, type2;`
                let oldcmdpos = incmdpos();
                let n: u32;
                let type2: wordcode;
                let p: usize;

                // c:1886-1889 — `array setting is cmplx because it can
                //   contain process substitutions`
                // c:1890 — `*cmplx = c = 1;`
                *cmplx = 1;
                // c:1891 — `p = ecadd(0);`
                p = ecadd(0);
                // c:1892 — `incmdpos = 0;`
                set_incmdpos(false);
                // c:1893-1897 — `+=` detection: if tokstr ends in `+`,
                // strip the `+` and use WC_ASSIGN_INC; else WC_ASSIGN_NEW.
                let raw = tokstr().unwrap_or_default();
                let (name, t2) = if raw.ends_with('+') {
                    (raw[..raw.len() - 1].to_string(), WC_ASSIGN_INC)
                } else {
                    (raw.clone(), WC_ASSIGN_NEW)
                };
                type2 = t2;
                // c:1898 — `ecstr(tokstr);` (tokstr now NUL-trimmed)
                ecstr(&name);
                // c:1899 — `cmdpush(CS_ARRAY);`
                cmdpush(CS_ARRAY as u8);
                // c:1900 — `zshlex();`
                zshlex();
                // c:1901 — `n = par_nl_wordlist();`
                n = par_nl_wordlist_wordcode();
                // c:1902 — `ecbuf[p] = WCB_ASSIGN(WC_ASSIGN_ARRAY, type2, n);`
                ECBUF.with_borrow_mut(|b| {
                    b[p] = WCB_ASSIGN(WC_ASSIGN_ARRAY, type2, n);
                });
                // c:1903 — `cmdpop();`
                cmdpop();
                // c:1904-1905 — `if (tok != OUTPAR) YYERROR(oecused);`
                if tok() != OUTPAR_TOK {
                    YYERROR!(oecused);
                }
                // c:1906 — `incmdpos = oldcmdpos;`
                set_incmdpos(oldcmdpos);
                // c:1907 — `isnull = 0;`
                isnull = false;
                // c:1908 — `assignments = 1;`
                assignments = true;
            }
            t if IS_REDIROP(t) => {
                // c:1900-1904 — `*cmplx = c = 1; nr += par_redir(&r,
                // NULL); continue;`. The wordcode-emitting redir is
                // distinct from the AST par_redir — it INSERTS
                // WCB_REDIR + fd + ecstrcode(name) at offset `r`
                // via ecispace, shifting any later words down.
                *cmplx = 1;
                let added = par_redir_wordcode(&mut r, None);
                if added == 0 {
                    break;
                }
                nr += added;
                continue;
            }
            _ => break,
        }
        zshlex(); // c:1907 `zshlex();`
    }

    // c:1920-1921 — `if (tok == AMPER || tok == AMPERBANG) YYERROR;`
    if tok() == AMPER || tok() == AMPERBANG {
        YYERROR!(oecused);
    }

    // c:1923 — `p = ecadd(WCB_SIMPLE(0));`
    let mut p = ecadd(WCB_SIMPLE(0));

    // c:1924-2105 — main words loop. is_typeset tracks whether the
    // outer command was `typeset`/`export`/etc. so the final
    // placeholder gets WCB_TYPESET instead of WCB_SIMPLE.
    let mut is_typeset = false;
    let mut postassigns: u32 = 0;
    let mut ppost: usize = 0;
    loop {
        match tok() {
            STRING_LEX | TYPESET => {
                // c:1926 — `int redir_var = 0;`
                let mut redir_var = false;
                // c:1928-1929 — `*cmplx = 1; incmdpos = 0;`
                *cmplx = 1;
                set_incmdpos(false);
                // c:1931-1932 — TYPESET → intypeset = is_typeset = 1.
                if tok() == TYPESET {
                    set_intypeset(true);
                    is_typeset = true;
                }
                let s = tokstr().unwrap_or_default();
                // c:1934-1974 — `{var}>file` brace-FD detection.
                // `if (!isset(IGNOREBRACES) && *tokstr == Inbrace)`
                let bytes = s.as_bytes();
                let first_is_inbrace = bytes.starts_with(&[0xee, 0x86, 0x8f])
                    || (bytes.len() >= 1 && bytes[0] == b'{');
                if !isset(IGNOREBRACES) && first_is_inbrace {
                    // c:1937-1938 — `char *eptr = tokstr + strlen(tokstr) - 1;`
                    //                `char *ptr = eptr;`
                    // C tests `*eptr == Outbrace` (0x90 marker or `}`) AND
                    // there's content between `{` and `}` (`ptr > tokstr + 1`).
                    let last_two_outbrace = bytes.len() >= 2
                        && (bytes.ends_with(&[0xee, 0x86, 0x90]) || bytes.last() == Some(&b'}'));
                    let opener_len = if bytes.starts_with(&[0xee, 0x86, 0x8f]) {
                        3
                    } else {
                        1
                    };
                    let closer_len = if bytes.ends_with(&[0xee, 0x86, 0x90]) {
                        3
                    } else if bytes.last() == Some(&b'}') {
                        1
                    } else {
                        0
                    };
                    if last_two_outbrace && bytes.len() > opener_len + closer_len {
                        // c:1944 — `if (itype_end(tokstr+1, IIDENT, 0) >= ptr)`
                        // Inner content is the identifier between `{` and `}`.
                        let inner_start = opener_len;
                        let inner_end = bytes.len() - closer_len;
                        let inner = &s[inner_start..inner_end];
                        if !inner.is_empty() && crate::ported::params::isident(inner) {
                            // c:1946-1948 — `char *idstring = dupstrpfx(...);`
                            //                `redir_var = 1; zshlex();`
                            let idstring = inner.to_string();
                            redir_var = true;
                            zshlex();
                            // c:1953-1958 — `if (IS_REDIROP(tok) && tokfd == -1)
                            //   { *cmplx = c = 1; nrediradd = par_redir(&r, id);
                            //     p += nrediradd; sr += nrediradd; }`
                            if IS_REDIROP(tok()) && tokfd() == -1 {
                                *cmplx = 1;
                                let nrediradd = par_redir_wordcode(&mut r, Some(&idstring));
                                p += nrediradd as usize;
                                sr += nrediradd;
                            } else if postassigns > 0 {
                                // c:1959-1966 — postassigns path: emit
                                // WCB_ASSIGN(SCALAR, INC, 0) + name + ""
                                postassigns += 1;
                                ecadd(WCB_ASSIGN(WC_ASSIGN_SCALAR, WC_ASSIGN_INC, 0));
                                ecstr(&s);
                                ecstr("");
                            } else {
                                // c:1968-1972 — `else { ecstr(toksave); argc++; }`
                                ecstr(&s);
                                argc += 1;
                            }
                        }
                    }
                }
                if !redir_var {
                    // c:1977-1996 — normal (non-redir-var) STRING/TYPESET.
                    if postassigns > 0 {
                        // c:1979-1989 — typeset with bare-name arg → INC
                        postassigns += 1;
                        ecadd(WCB_ASSIGN(WC_ASSIGN_SCALAR, WC_ASSIGN_INC, 0));
                        ecstr(&s);
                        ecstr("");
                    } else {
                        ecstr(&s);
                        argc += 1;
                    }
                    zshlex();
                }
                isnull = false;
            }
            ENVSTRING => {
                // c:2005-2026 — mid-cmd ENVSTRING (under intypeset
                // context). Emits WCB_ASSIGN(SCALAR, NEW, 0) then
                // ecstr(name) + ecstr(value), tracking the first
                // postassign offset in `ppost` (which the trailing
                // WCB_TYPESET header points to).
                if postassigns == 0 {
                    ppost = ecadd(0);
                }
                postassigns += 1;
                // c:2010-2014 — `for (ptr = tokstr; *ptr && *ptr != Inbrack
                // && *ptr != '=' && *ptr != '+'; ptr++); if (*ptr == Inbrack)
                // skipparens(Inbrack, Outbrack, &ptr);`.
                let raw = tokstr().unwrap_or_default();
                let bytes: Vec<char> = raw.chars().collect();
                let mut idx = 0usize;
                while idx < bytes.len() {
                    let ch = bytes[idx];
                    if ch == '\u{e191}' /* Inbrack */
                        || ch == '=' || ch == '+' || ch == '\u{e18d}'
                    /* Equals */
                    {
                        break;
                    }
                    idx += 1;
                }
                if idx < bytes.len() && bytes[idx] == '\u{e191}'
                /* Inbrack */
                {
                    // c:2014 — `skipparens(Inbrack, Outbrack, &ptr);`.
                    let byte_off: usize = bytes[..idx].iter().map(|c| c.len_utf8()).sum();
                    let mut cursor: &str = &raw[byte_off..];
                    let _ = crate::ported::utils::skipparens('\u{e191}', '\u{e192}', &mut cursor);
                    let consumed = raw.len() - byte_off - cursor.len();
                    let advance_chars = raw[byte_off..byte_off + consumed].chars().count();
                    idx += advance_chars;
                    while idx < bytes.len() {
                        let ch = bytes[idx];
                        if ch == '=' || ch == '+' || ch == '\u{e18d}' {
                            break;
                        }
                        idx += 1;
                    }
                }
                let name: String = bytes[..idx].iter().collect();
                let str_off = if idx < bytes.len() && (bytes[idx] == '=' || bytes[idx] == '\u{e18d}')
                {
                    idx + 1
                } else {
                    idx
                };
                let value: String = bytes[str_off..].iter().collect();
                // c:2016-2019 — `name` is NUL-terminated inside tokstr.
                // !!! RUST-ONLY !!! — write the cut through to zshlextext (see the
                // leading-assignment loop in par_simple).
                crate::ported::lex::LEX_ZSHLEXTEXT.with_borrow_mut(|t| {
                    if let Some(text) = t.as_mut().filter(|text| text.starts_with(name.as_str())) {
                        text.truncate(name.len());
                    }
                });
                ecadd(WCB_ASSIGN(WC_ASSIGN_SCALAR, WC_ASSIGN_NEW, 0));
                ecstr(&name);
                ecstr(&value);
                isnull = false;
                zshlex();
            }
            ENVARRAY => {
                // c:2027-2050 — mid-cmd ENVARRAY (typeset N=(…) form).
                // C tracks postassigns + ppost the same as ENVSTRING,
                // but the inner emit is WCB_ASSIGN(ARRAY, NEW, n)
                // with `n` patched in after par_nl_wordlist consumes
                // the elements. C also toggles intypeset=0 around the
                // wordlist so the lexer doesn't try to re-emit
                // assignments inside the array.
                *cmplx = 1;
                if postassigns == 0 {
                    ppost = ecadd(0);
                }
                postassigns += 1;
                let parr = ecadd(0);
                let raw = tokstr().unwrap_or_default();
                let is_inc = raw.ends_with('+');
                let name = if is_inc {
                    &raw[..raw.len() - 1]
                } else {
                    raw.as_str()
                };
                let flag = if is_inc { WC_ASSIGN_INC } else { WC_ASSIGN_NEW };
                ecstr(name);
                cmdpush(CS_ARRAY as u8);
                set_intypeset(false);
                zshlex();
                // c:2044 — `n = par_nl_wordlist();` (parse.c:2379-2391).
                // SEPER + NEWLIN both allowed between elements.
                let mut nelem = 0u32;
                loop {
                    let t = tok();
                    if t != STRING_LEX && t != SEPER && t != NEWLIN {
                        break;
                    }
                    if t == STRING_LEX {
                        ecstr(&tokstr().unwrap_or_default());
                        nelem += 1;
                    }
                    zshlex();
                }
                ECBUF.with_borrow_mut(|b| {
                    if parr < b.len() {
                        b[parr] = WCB_ASSIGN(WC_ASSIGN_ARRAY, flag, nelem);
                    }
                });
                cmdpop();
                set_intypeset(true);
                if tok() != OUTPAR_TOK {
                    YYERROR!(oecused);
                }
                isnull = false;
                zshlex();
            }
            t if IS_REDIROP(t) => {
                // c:1999-2010 — `nrediradd = par_redir(&r, NULL);
                // p += nrediradd; if (ppost) ppost += nrediradd;
                // sr += nrediradd;`
                *cmplx = 1;
                let added = par_redir_wordcode(&mut r, None);
                if added == 0 {
                    break;
                }
                p += added as usize;
                if ppost != 0 {
                    ppost += added as usize;
                }
                sr += added;
            }
            INOUTPAR => {
                // c:2051 — `} else if (tok == INOUTPAR) {`
                // c:2052 — `zlong oldlineno = lineno;`
                let oldlineno = lineno();
                // c:2053 — `int onp, so, oecssub = ecssub;`
                let oecssub = ECSSUB.get();
                // c:2055-2057 — `if (!isset(MULTIFUNCDEF) && argc > 1) YYERROR;`
                if !isset(MULTIFUNCDEF) && argc > 1 {
                    YYERROR!(oecused);
                }
                // c:2058-2060 — `if (assignments || postassigns) YYERROR;`
                if assignments || postassigns > 0 {
                    YYERROR!(oecused);
                }
                // c:2061-2068 — hasalias check + zwarn — skipped (no
                // alias tracking on the wordcode path).

                // c:2070 — `*cmplx = c;`
                *cmplx = c_saved;
                // c:2071 — `lineno = 0;`
                set_lineno(0);
                // c:2072 — `incmdpos = 1;`
                set_incmdpos(true);
                // c:2073 — `cmdpush(CS_FUNCDEF);`
                cmdpush(CS_FUNCDEF as u8);
                // c:2074 — `zshlex();`
                zshlex();
                // c:2075-2076 — `while (tok == SEPER) zshlex();`
                while tok() == SEPER {
                    zshlex();
                }
                // c:2079 — `ecispace(p + 1, 1); ecbuf[p+1] = argc;
                // ecadd(0)*4`. Insert the argc word at p+1, then
                // append 4 placeholder words.
                ecispace(p + 1, 1);
                ECBUF.with_borrow_mut(|b| {
                    if p + 1 < b.len() {
                        b[p + 1] = argc;
                    }
                });
                // c:2080-2083 — four metadata placeholder slots.
                ecadd(0);
                ecadd(0);
                ecadd(0);
                ecadd(0);

                // c:2085 — `ecnfunc++;`
                ECNFUNC.set(ECNFUNC.get() + 1);
                // c:2086 — `ecssub = so = ecsoffs;`
                let so = ECSOFFS.get();
                ECSSUB.set(so);
                // c:2087 — `onp = ecnpats;`
                let onp = ECNPATS.with(|cc| cc.get());
                // c:2088 — `ecnpats = 0;`
                ECNPATS.with(|cc| cc.set(0));

                // c:2091 — `int c = 0;` — INNER cmplx for the body
                // parse. Local to each branch; C's enclosing *cmplx
                // is NOT modified by the body.
                let mut body_c: i32 = 0;
                // c:2090 — `if (tok == INBRACE) {`
                if tok() == INBRACE_TOK {
                    // c:2093 — `zshlex();`
                    zshlex();
                    // c:2094 — `par_list(&c);`
                    par_list_wordcode(&mut body_c);
                    // c:2095-2101 — `if (tok != OUTBRACE) { cmdpop();
                    //   lineno += oldlineno; ecnpats = onp;
                    //   ecssub = oecssub; YYERROR; }`
                    if tok() != OUTBRACE_TOK {
                        cmdpop();
                        set_lineno(lineno() + oldlineno);
                        ECNPATS.with(|cc| cc.set(onp));
                        ECSSUB.set(oecssub);
                        YYERROR!(oecused);
                    }
                    // c:2102-2105 — `if (argc == 0) incmdpos = 0;`
                    if argc == 0 {
                        set_incmdpos(false);
                    }
                    // c:2106 — `zshlex();`
                    zshlex();
                } else {
                    // c:2107-2132 — short-body funcdef form: `f() cmd`
                    // or `() cmd`. Wraps single par_cmd result in a
                    // synthetic WC_LIST / WC_SUBLIST /
                    // WC_PIPE(WC_PIPE_END, 0) header trio.
                    let ll = ecadd(0);
                    let sl = ecadd(0);
                    ecadd(WCB_PIPE(WC_PIPE_END, 0));
                    let ok = par_cmd_wordcode(&mut body_c, if argc == 0 { 1 } else { 0 });
                    if !ok {
                        cmdpop();
                        YYERROR!(oecused);
                    }
                    if argc == 0 {
                        // c:2118-2127 — anonymous funcdef may take args
                        // after the body; first one already read.
                        set_incmdpos(false);
                    }
                    // c:2130-2131 — inner sublist/list use inner cmplx.
                    let used = ECUSED.get() as usize;
                    set_sublist_code(
                        sl,
                        WC_SUBLIST_END as i32,
                        0,
                        (used.saturating_sub(1 + sl)) as i32,
                        body_c != 0,
                    );
                    set_list_code(ll, Z_SYNC | Z_END, body_c != 0);
                }
                let _ = body_c;
                // c:2133 — `cmdpop();`
                cmdpop();

                // c:2135 — `ecadd(WCB_END());`
                ecadd(WCB_END());
                // c:2136-2139 — fill 4 metadata slots at p+argc+2..5
                let p_argc = (p + (argc as usize) + 2) as usize;
                let cur_so = ECSOFFS.get();
                let np_now = ECNPATS.with(|cc| cc.get());
                ECBUF.with_borrow_mut(|b| {
                    b[p_argc] = (so - oecssub) as wordcode;
                    b[p_argc + 1] = (cur_so - so) as wordcode;
                    b[p_argc + 2] = np_now as wordcode;
                    b[p_argc + 3] = 0;
                });

                // c:2141-2143 — `ecnpats = onp; ecssub = oecssub; ecnfunc++;`
                ECNPATS.with(|cc| cc.set(onp));
                ECSSUB.set(oecssub);
                ECNFUNC.set(ECNFUNC.get() + 1);

                // c:2145 — `ecbuf[p] = WCB_FUNCDEF(ecused - 1 - p);`
                let used = ECUSED.get() as usize;
                let header_off = used.saturating_sub(1 + p) as wordcode;
                ECBUF.with_borrow_mut(|b| {
                    b[p] = WCB_FUNCDEF(header_off);
                });

                // c:2147-2172 — `if (argc == 0) { /* anonymous fn args */ }`
                if argc == 0 {
                    // c:2150 — `int parg = ecadd(0);`
                    let mut parg = ecadd(0);
                    // c:2151 — `ecadd(0);`
                    ecadd(0);
                    // c:2152 — `while (tok == STRING || IS_REDIROP(tok)) {`
                    while tok() == STRING_LEX || IS_REDIROP(tok()) {
                        if tok() == STRING_LEX {
                            // c:2155-2157
                            ecstr(&tokstr().unwrap_or_default());
                            argc += 1;
                            zshlex();
                        } else {
                            // c:2159-2165 — *cmplx=c=1; nrediradd=par_redir;
                            // p += nrediradd; ppost += nrediradd if ppost;
                            // sr += nrediradd; parg += nrediradd;
                            *cmplx = 1;
                            let added = par_redir_wordcode(&mut r, None);
                            if added == 0 {
                                break;
                            }
                            p += added as usize;
                            if ppost != 0 {
                                ppost += added as usize;
                            }
                            sr += added;
                            parg += added as usize;
                        }
                    }
                    // c:2168-2169 — `if (argc > 0) *cmplx = 1;`
                    if argc > 0 {
                        *cmplx = 1;
                    }
                    // c:2170 — `ecbuf[parg] = ecused - parg;`
                    // c:2171 — `ecbuf[parg+1] = argc;`
                    let used2 = ECUSED.get() as usize;
                    ECBUF.with_borrow_mut(|b| {
                        b[parg] = (used2 - parg) as wordcode;
                        b[parg + 1] = argc;
                    });
                }
                // c:2173 — `lineno += oldlineno;`
                set_lineno(lineno() + oldlineno);

                // c:2175-2177 — `isfunc = 1; isnull = 0; break;`
                isfunc = true;
                isnull = false;
                break;
            }
            _ => break,
        }
    }

    // c:2173-2176 — `if (isnull && !(sr + nr)) { ecused = oecused;
    // return 0; }` — undo everything including pre-cmd assignments
    // if no actual command word emerged.
    if isnull && sr + nr == 0 && !assignments {
        ECUSED.set(p as i32);
        return 0;
    }
    // c:2186-2187 — `incmdpos = 1; intypeset = 0;` — reset before
    // the placeholder patch so the next-token lex doesn't carry
    // typeset/incond state.
    set_incmdpos(true);
    set_intypeset(false);
    // c:2189-2199 — `if (!isfunc) { if (is_typeset) ecbuf[p] =
    // WCB_TYPESET(argc); else ecbuf[p] = WCB_SIMPLE(argc); }`.
    // When isfunc=true the INOUTPAR branch already wrote WCB_FUNCDEF
    // at p; do NOT clobber it.
    if !isfunc {
        let header = if is_typeset {
            if postassigns > 0 {
                ECBUF.with_borrow_mut(|b| {
                    if ppost < b.len() {
                        b[ppost] = postassigns;
                    }
                });
            } else {
                ecadd(0);
            }
            WCB_TYPESET(argc)
        } else {
            WCB_SIMPLE(argc)
        };
        ECBUF.with_borrow_mut(|b| {
            if p < b.len() {
                b[p] = header;
            }
        });
    }
    1 + sr
}

/// Port of `par_redir` from `Src/parse.c:2229` — C decl `par_redir(int *rp, char *idstring)`. Rust fn `par_redir_wordcode` is the wordcode-emitting variant (the AST twin is `par_redir` at parse.rs:3096).
/// the wordcode-emitting variant that
/// pushes WCB_REDIR + fd + ecstrcode(name) into ECBUF. Distinct
/// from the AST `par_redir` (parse.rs:3771) which builds a
/// ZshRedir struct for the AST executor pipeline.
///
/// Returns the number of wordcodes added (3 for the basic shape,
/// 4 with idstring, 5 for HEREDOC[DASH] which carries the
/// terminator strings inline). Returns 0 on parse error.
///
/// `idstring` mirrors C's `char *idstring` parameter — `None` =
/// NULL (no `{var}>file` brace-FD shape), `Some(id)` = the captured
/// `{var}` name. C callers without a var pass NULL inline; Rust
/// callers do the same with `None`.
fn par_redir_wordcode(rp: &mut usize, idstring: Option<&str>) -> i32 {
    // c:2231 — `int r = *rp, type, fd1, oldcmdpos, oldnc, ncodes;`
    let r: usize = *rp;
    let mut r#type: i32;
    let fd1: i32;
    let oldcmdpos: bool;
    let oldnc: i32;
    let mut ncodes: usize;
    // c:2232 — `char *name;`
    let name: String;

    // c:2234 — `oldcmdpos = incmdpos;`
    oldcmdpos = incmdpos();
    // c:2235 — `incmdpos = 0;`
    set_incmdpos(false);
    // c:2236 — `oldnc = nocorrect;`
    oldnc = nocorrect();
    // c:2237-2238 — `if (tok != INANG && tok != INOUTANG) nocorrect = 1;`
    if tok() != INANG_TOK && tok() != INOUTANG {
        set_nocorrect(1);
    }
    // c:2239 — `type = redirtab[tok - OUTANG];`
    // Map current redirop token to redirtab index — matches order of
    // C `enum { OUTANG, OUTANGBANG, DOUTANG, DOUTANGBANG, INANG,
    // INOUTANG, DINANG, DINANGDASH, INANGAMP, OUTANGAMP, AMPOUTANG,
    // OUTANGAMPBANG, DOUTANGAMP, DOUTANGAMPBANG, TRINANG }`.
    r#type = match tok() {
        OUTANG_TOK => REDIR_WRITE,
        OUTANGBANG => REDIR_WRITENOW,
        DOUTANG => REDIR_APP,
        DOUTANGBANG => REDIR_APPNOW,
        INANG_TOK => REDIR_READ,
        INOUTANG => REDIR_READWRITE,
        DINANG => REDIR_HEREDOC,
        DINANGDASH => REDIR_HEREDOCDASH,
        INANGAMP => REDIR_MERGEIN,
        OUTANGAMP => REDIR_MERGEOUT,
        AMPOUTANG => REDIR_ERRWRITE,
        OUTANGAMPBANG => REDIR_ERRWRITENOW,
        DOUTANGAMP => REDIR_ERRAPP,
        DOUTANGAMPBANG => REDIR_ERRAPPNOW,
        TRINANG => REDIR_HERESTR,
        _ => {
            set_incmdpos(oldcmdpos);
            set_nocorrect(oldnc);
            return 0;
        }
    };
    // c:2240 — `fd1 = tokfd;`
    fd1 = tokfd();
    // The operator's own text, kept for the YYERROR path below. C does not
    // need this: `zshlextext` (c:225) is a pointer alias that still points at
    // the redirection operator's lexeme after the `zshlex()` below moves on to
    // a token that carries no text (EOF/NEWLIN), which is why zsh reports
    // "parse error near `>'" and not a bare "parse error". This port derives
    // yyerror's token text from `tokstr`/`tokstrings[tok]`, both of which are
    // empty for those tokens, so the lexeme has to be carried by hand.
    let redir_op_text: Option<String> = {
        let i = tok() as usize;
        if i < crate::ported::lex::tokstrings.len() {
            crate::ported::lex::tokstrings[i].map(|t| t.to_string())
        } else {
            None
        }
    };
    // c:2241 — `zshlex();`
    zshlex();
    // c:2242-2243 — `if (tok != STRING && tok != ENVSTRING) YYERROR(ecused);`
    if tok() != STRING_LEX && tok() != ENVSTRING {
        set_incmdpos(oldcmdpos);
        set_nocorrect(oldnc);
        // c:2243 — `YYERROR(ecused)`, which is
        // `{ tok = LEXERR; ecused = (O); return 0; }` (c:87). It prints
        // NOTHING: the diagnostic comes from `yyerror` (c:2733) once the
        // parse unwinds, as "parse error near `X'" built from the offending
        // token. The port raised its own `zerr("expected word after
        // redirection")` instead — a message with no counterpart in zsh — so
        // `echo >`, `echo <>`, `cat <<` and friends reported
        //   zshrs: zsh:1: expected word after redirection
        // where zsh reports
        //   zsh:1: parse error near `>'
        if crate::ported::lex::tokstr().is_none() {
            crate::ported::lex::set_tokstr(redir_op_text);
        }
        set_tok(LEXERR);
        return 0;
    }
    // c:2244 — `incmdpos = oldcmdpos;`
    set_incmdpos(oldcmdpos);
    // c:2245 — `nocorrect = oldnc;`
    set_nocorrect(oldnc);

    // c:2248-2249 — `if (fd1 == -1) fd1 = IS_READFD(type) ? 0 : 1;`
    let fd1 = if fd1 == -1 {
        if is_readfd(r#type) {
            0
        } else {
            1
        }
    } else {
        fd1
    };

    // c:2251 — `name = tokstr;`
    name = tokstr().unwrap_or_default();

    // c:2253-2321 — switch on type:
    match r#type {
        // c:2254-2300 — REDIR_HEREDOC / REDIR_HEREDOCDASH
        x if x == REDIR_HEREDOC || x == REDIR_HEREDOCDASH => {
            // c:2257 — `struct heredocs **hd;`
            // c:2258 — `int htype = type;`
            let htype = r#type;
            // c:2260-2261 — `if (strchr(tokstr, '\n')) YYERROR(ecused);`
            if name.contains('\n') {
                YYERROR!(ECUSED.get());
            }
            // c:2263-2273 — `ncodes = 5; if (idstring) { type |= MASK; ncodes = 6; }`
            if idstring.is_some() {
                r#type |= REDIR_VARID_MASK;
                ncodes = 6;
            } else {
                ncodes = 5;
            }
            // c:2277 — `ecispace(r, ncodes);`
            ecispace(r, ncodes);
            // c:2278 — `*rp = r + ncodes;`
            *rp = r + ncodes;
            // c:2279 — `ecbuf[r] = WCB_REDIR(type | REDIR_FROM_HEREDOC_MASK);`
            ECBUF.with_borrow_mut(|b| {
                b[r] = WCB_REDIR((r#type | REDIR_FROM_HEREDOC_MASK) as wordcode);
                // c:2280 — `ecbuf[r + 1] = fd1;`
                b[r + 1] = fd1 as wordcode;
            });
            // c:2282-2286 — r+2..4 are filled later by setheredoc.
            // c:2287-2288 — `if (idstring) ecbuf[r + 5] = ecstrcode(idstring);`
            if let Some(id) = idstring {
                let coded = ecstrcode(id);
                ECBUF.with_borrow_mut(|b| {
                    b[r + 5] = coded;
                });
            }
            // c:2290-2296 — `for (hd = &hdocs; *hd; hd = &(*hd)->next);
            //                 *hd = zalloc(sizeof(struct heredocs));
            //                 (*hd)->next = NULL;
            //                 (*hd)->type = htype;
            //                 (*hd)->pc = r;
            //                 (*hd)->str = tokstr;`
            HDOCS.with_borrow_mut(|head| {
                let mut cur = head;
                while cur.is_some() {
                    cur = &mut cur.as_mut().unwrap().next; // c:2290
                }
                *cur = Some(Box::new(crate::ported::zsh_h::heredocs {
                    // c:2292-2296
                    next: None,
                    typ: htype,
                    pc: r as i32,
                    str: Some(name.clone()),
                }));
            });
            // c:2298 — `zshlex();`
            zshlex();
            // c:2299 — `return ncodes;`
            return ncodes as i32;
        }
        // c:2301-2308 — REDIR_WRITE / REDIR_WRITENOW
        x if x == REDIR_WRITE || x == REDIR_WRITENOW => {
            // c:2303-2305 — `if (tokstr[0] == OutangProc && tokstr[1] == Inpar)
            //                  type = REDIR_OUTPIPE;`
            let nb: Vec<char> = name.chars().collect();
            if nb.len() >= 2 && nb[0] == '\u{e196}' && nb[1] == '\u{e188}' {
                r#type = REDIR_OUTPIPE;
            } else if nb.len() >= 2 && nb[0] == '\u{e194}' && nb[1] == '\u{e188}' {
                // c:2306-2307 — `else if (tokstr[0] == Inang && tokstr[1] == Inpar) YYERROR;`
                YYERROR!(ECUSED.get());
            }
        }
        // c:2309-2315 — REDIR_READ
        x if x == REDIR_READ => {
            let nb: Vec<char> = name.chars().collect();
            if nb.len() >= 2 && nb[0] == '\u{e194}' && nb[1] == '\u{e188}' {
                r#type = REDIR_INPIPE;
            } else if nb.len() >= 2 && nb[0] == '\u{e196}' && nb[1] == '\u{e188}' {
                YYERROR!(ECUSED.get());
            }
        }
        // c:2316-2320 — REDIR_READWRITE
        x if x == REDIR_READWRITE => {
            let nb: Vec<char> = name.chars().collect();
            if nb.len() >= 2 && (nb[0] == '\u{e194}' || nb[0] == '\u{e196}') && nb[1] == '\u{e188}' {
                r#type = if nb[0] == '\u{e194}' {
                    REDIR_INPIPE
                } else {
                    REDIR_OUTPIPE
                };
            }
        }
        _ => {}
    }
    // c:2322 — `zshlex();`
    zshlex();

    // c:2326-2333 — `if (idstring) { type |= MASK; ncodes = 4; } else ncodes = 3;`
    if idstring.is_some() {
        r#type |= REDIR_VARID_MASK;
        ncodes = 4;
    } else {
        ncodes = 3;
    }

    // c:2334 — `ecispace(r, ncodes);`
    ecispace(r, ncodes);
    // c:2335 — `*rp = r + ncodes;`
    *rp = r + ncodes;
    // c:2336 — `ecbuf[r] = WCB_REDIR(type);`
    let coded_name = ecstrcode(&name);
    ECBUF.with_borrow_mut(|b| {
        b[r] = WCB_REDIR(r#type as wordcode);
        // c:2337 — `ecbuf[r + 1] = fd1;`
        b[r + 1] = fd1 as wordcode;
        // c:2338 — `ecbuf[r + 2] = ecstrcode(name);`
        b[r + 2] = coded_name;
    });
    // c:2339-2340 — `if (idstring) ecbuf[r + 3] = ecstrcode(idstring);`
    if let Some(id) = idstring {
        let coded_id = ecstrcode(id);
        ECBUF.with_borrow_mut(|b| {
            b[r + 3] = coded_id;
        });
    }
    // c:2342 — `return ncodes;`
    ncodes as i32
}

/// Port of `IS_READFD` from `Src/zsh.h:407` — C decl `#define IS_READFD(X) (((X)>=REDIR_READWRITE && (X)<=REDIR_MERGEIN) || (X)==REDIR_INPIPE)`. Rust fn `is_readfd`. DIVERGENCE: the Rust port covers the `REDIR_READWRITE..REDIR_MERGEIN` range but omits C's `|| (X)==REDIR_INPIPE` arm.
/// default fd (0 for read-ish, 1 for write-ish) when none specified.
fn is_readfd(t: i32) -> bool {
    matches!(
        t,
        x if x == REDIR_READ
            || x == REDIR_READWRITE
            || x == REDIR_MERGEIN
            || x == REDIR_HEREDOC
            || x == REDIR_HEREDOCDASH
            || x == REDIR_HERESTR
    )
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the AST-pipeline whole-program entry. C's counterparts `parse_event`
/// (c:614) and `par_event` (c:635) are ported separately; this one loops
/// `parse_program_until` with no end-token sentinel.
/// Parse a program (list of lists)
/// Parse a complete program (top-level entry). Calls
/// parse_program_until with no end-token sentinel. Direct port of
/// zsh/Src/parse.c:614-720 `parse_event` / `par_list` /
/// `par_event` flow. C distinguishes COND_EVENT (single command
/// for here-string) from full event parse; zshrs's parse_program
/// is the full-event entry.
fn parse_program() -> ZshProgram {
    parse_program_until(None, false)
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the AST-pipeline event loop modelled on the body of `par_event`
/// (c:635-695); `single_event` reproduces C's `endtok == ENDINPUT` top-level
/// mode.
/// Parse a program until we hit an end token
/// Parse a program until one of `end_tokens` is seen (or EOF).
/// Drives par_list in a loop. C equivalent: the body of par_event
/// (parse.c:635-695) iterating par_list against the lexer.
///
/// `single_event` mirrors C par_event's `endtok == ENDINPUT` top-level
/// mode: when true, parse ONE event (the sublists `;`/`&`-chained on one
/// logical line, including any multi-line compound) and STOP at the
/// terminating top-level newline WITHOUT reading the next line — so
/// loop() executes the event then re-reads for the next, interleaving
/// input with execution exactly as zsh does. Whole-program and
/// nested-body parses pass false (multi-list to EOF / end token).
fn parse_program_until(end_tokens: Option<&[lextok]>, single_event: bool) -> ZshProgram {
    let mut lists = Vec::new();

    loop {
        // Skip separators
        while tok() == SEPER || tok() == NEWLIN {
            // !!! DASH-FAITHFUL GATE (no C counterpart) !!! dash's grammar
            // takes one `;` after a command and none before it: a leading or
            // doubled `;` is `Syntax error: ";" unexpected`. Newlines may repeat.
            if tok() == SEPER
                && crate::dash_mode::dash_faithful()
                && crate::ported::lex::LEX_ISNEWLIN.with(|c| c.get()) == 0
            {
                zerr("Syntax error: \";\" unexpected");
                set_tok(LEXERR);
                break;
            }
            zshlex();
        }

        if tok() == ENDINPUT {
            break;
        }
        if tok() == LEXERR {
            // c:Src/parse.c:671-680 par_event — when the lexer
            // returned LEXERR (e.g. unbalanced `$((1+(2))` math
            // sub, unterminated string, etc.), C emits `yyerror(1)`
            // and sets errflag so the script aborts with a parse
            // error diagnostic + non-zero exit. zshrs's
            // parse_program_until previously just `break`'d on
            // LEXERR, silently swallowing the malformed input and
            // exiting rc=0 — so `$((1+(2))` ran as if it were
            // empty. Bug #529 in docs/BUGS.md. Emit yyerror
            // mirroring the C behaviour; the broken script then
            // surfaces the parse error to the caller.
            // c:Src/parse.c — empty-msg yyerror call mapped to the
            // C-faithful `yyerror(0)` (zshrs's previous shape).
            yyerror(0);
            break;
        }

        // Check for end tokens
        if let Some(end_toks) = end_tokens {
            if end_toks.contains(&tok()) {
                break;
            }
        }

        // Also stop at these tokens when not explicitly looking for them
        // Note: Else/Elif/Then are NOT here - they're handled by par_if
        // to allow nested if statements inside case arms, loops, etc.
        //
        // c:Src/parse.c:par_event — when an orphan terminator (DONE
        // outside a loop, FI outside an if, ESAC outside a case)
        // appears at the top level (end_tokens=None), C errors via
        // YYERROR. zshrs's `break` silently accepted `done`/`fi`/
        // `esac` as no-op input. Error at the outermost call so
        // unscoped terminators don't sneak through; nested calls
        // still break cleanly via the end_tokens contains-check
        // above.
        match tok() {
            DONE | FI | ESAC | DOLOOP | ZEND if end_tokens.is_none() => {
                // c:Src/parse.c:par_event — emit the specific token
                // name (`done`, `fi`, `esac`, `do`) so error-parsing
                // tools can identify the unmatched terminator. C zsh
                // writes `parse error near \`<tok>'`; the Rust port
                // was emitting a generic "orphan terminator" string.
                // Bug #142, #413.
                let name = match tok() {
                    DONE => "done",
                    FI => "fi",
                    ESAC => "esac",
                    DOLOOP => "do",
                    // c:Src/parse.c:1184-1190 — `end` closes a loop
                    // body ONLY under `csh || isset(CSHJUNKIELOOPS)`.
                    // With the option off the short-loop form
                    // (par_save_list1, c:1193) consumes one command
                    // and leaves ZEND in command position, where
                    // par_event errors. zshrs broke out silently, so
                    // `unsetopt cshjunkieloops; for f in a b; print
                    // $f; end` ran and exited 0 instead of the
                    // expected "parse error near `end'" + status 1
                    // (E01options.ztst:13).
                    ZEND => "end",
                    _ => "orphan terminator",
                };
                zerr(&format!("parse error near `{}'", name));
                break;
            }
            DSEMI | SEMIAMP | SEMIBAR if end_tokens.is_none() => {
                // c:Src/parse.c:par_event — case-arm terminators
                // (`;;`, `;&`, `;|`) outside a case construct are a
                // parse error. zshrs's `break` silently accepted them
                // at top level, truncating the rest of the script.
                // Bug #141 in docs/BUGS.md.
                let name = match tok() {
                    DSEMI => ";;",
                    SEMIAMP => ";&",
                    SEMIBAR => ";|",
                    _ => "case terminator",
                };
                zerr(&format!("parse error near `{}'", name));
                break;
            }
            OUTBRACE_TOK if end_tokens.is_none() => {
                // c:Src/parse.c:par_event — orphan `}` (no matching
                // `{` opener) at top level is a parse error. zshrs's
                // generic break swallowed it silently, leaving the
                // `echo a` in `echo a }` running and ignoring the
                // stray brace. Bug #168 in docs/BUGS.md.
                zerr("parse error near `}'");
                break;
            }
            OUTBRACE_TOK | DSEMI | SEMIAMP | SEMIBAR | DONE | FI | ESAC | ZEND => break,
            _ => {}
        }

        match par_list(single_event) {
            Some((list, terminated)) => {
                let detected = simple_name_with_inoutpar(&list);
                let was_detected = detected.is_some();
                lists.push(list);
                // Synthesize a FuncDef for the `name() { body }` shape
                // at parse time so body_source is captured while the
                // lexer still has the input. The lexer port emits
                // `name(` as a single Word ending in `<Inpar><Outpar>`,
                // so the Simple list is followed by an Inbrace once
                // separators are skipped. For `name() cmd args` the
                // body has already been swallowed into the same
                // Simple's words tail — synthesize directly from there.
                if let Some((names, body_argv)) = detected {
                    if !body_argv.is_empty() {
                        // One-line body already in the Simple. Build
                        // a Simple from body_argv as the function body.
                        lists.pop();
                        let body_simple = ZshCommand::Simple(ZshSimple {
                            assigns: Vec::new(),
                            words: body_argv,
                            redirs: Vec::new(),
                            typeset_reswd: false,
                            via_alias: None,
                        });
                        let body_list = ZshList {
                            sublist: ZshSublist {
                                pipe: ZshPipe {
                                    cmd: body_simple,
                                    next: None,
                                    lineno: lineno(),
                                    merge_stderr: false,
                                },
                                next: None,
                                flags: SublistFlags::default(),
                            },
                            flags: ListFlags::default(),
                        };
                        let funcdef = ZshCommand::FuncDef(ZshFuncDef {
                            names,
                            body: Box::new(ZshProgram {
                                lists: vec![body_list],
                            }),
                            tracing: false,
                            keyword_form: false,
                            auto_call_args: None,
                            body_source: None,
                        });
                        let synthetic = ZshList {
                            sublist: ZshSublist {
                                pipe: ZshPipe {
                                    cmd: funcdef,
                                    next: None,
                                    lineno: lineno(),
                                    merge_stderr: false,
                                },
                                next: None,
                                flags: SublistFlags::default(),
                            },
                            flags: ListFlags::default(),
                        };
                        lists.push(synthetic);
                        continue;
                    }
                    // Else: words.len() == 1 (only the trailing `name()`
                    // word), brace body follows. `names` may carry
                    // multiple identifiers from the `fna fnb fnc()`
                    // shorthand — all share the same brace body per
                    // src/zsh/Src/parse.c:1666 par_funcdef wordlist.
                    // Skip separators on the real lexer; safe because
                    // parse_program's next iteration would also skip them.
                    while tok() == SEPER || tok() == NEWLIN {
                        zshlex();
                    }
                    if tok() == INBRACE_TOK {
                        // Capture body_start BEFORE the lexer
                        // advances past the first body token. The
                        // outer zshlex() consumed `{`; lexer.pos
                        // is now right after `{`. The next
                        // `zshlex()` would advance past `echo`,
                        // making body_start land mid-body and
                        // lose the first word — `typeset -f f`
                        // printed `a; echo b` instead of
                        // `echo a; echo b` for `f() { echo a;
                        // echo b }`.
                        let body_mark = crate::funcdef_capture::body_mark_begin();
                        zshlex();
                        // c:Src/parse.c — synth funcdef body terminates
                        // at OUTBRACE_TOK. Explicit end-token avoids
                        // the top-level stray-`}` arm. Bug #167/#168.
                        let body = parse_program_until(Some(&[OUTBRACE_TOK]), false);
                        // Bug #642 family: slice THROUGH pos() so the funcdef
                        // `}` is always inside the slice, then strip that
                        // single trailing brace (+ the `;`/`\n` separator
                        // before it). The prior `pos()-1` form left the `}`
                        // in `body_source` for the inline `name() { body }`
                        // shape (this arm) — so `${functions[name]}` returned
                        // `body }` and `.zinit-diff-functions`'
                        // `${(qk)functions[@]}` re-parsed it into a
                        // `parse error near '}'` on every function. Match the
                        // canonical strip used by the other two funcdef arms
                        // (parse.rs:2457 / 9528).
                        let body_source = crate::funcdef_capture::body_text(body_mark)
                            .map(|s| {
                                let t = s.trim();
                                let t = t.strip_suffix('}').unwrap_or(t).trim_end();
                                let t = t
                                    .trim_end_matches(|c: char| c == ';' || c == '\n')
                                    .trim_end();
                                t.to_string()
                            })
                            .filter(|s| !s.is_empty());
                        // c:Src/parse.c par_funcdef bakes alias expansion into the wordcode; see
                        // vm_helper::funcdef_note_resolved_body.
                        crate::vm_helper::funcdef_note_resolved_body(body_source.as_deref());
                        if tok() == OUTBRACE_TOK {
                            zshlex();
                        }
                        // Replace the Simple list with a FuncDef list.
                        lists.pop();
                        let funcdef = ZshCommand::FuncDef(ZshFuncDef {
                            names,
                            body: Box::new(body),
                            tracing: false,
                            keyword_form: false,
                            auto_call_args: None,
                            body_source,
                        });
                        let synthetic = ZshList {
                            sublist: ZshSublist {
                                pipe: ZshPipe {
                                    cmd: funcdef,
                                    next: None,
                                    lineno: lineno(),
                                    merge_stderr: false,
                                },
                                next: None,
                                flags: SublistFlags::default(),
                            },
                            flags: ListFlags::default(),
                        };
                        lists.push(synthetic);
                    } else if !matches!(tok(), ENDINPUT | OUTBRACE_TOK | SEPER | NEWLIN) {
                        // No-brace one-line body: `foo() echo hello`.
                        // Parse a single command for the body.
                        let body_cmd = par_cmd(false);
                        if let Some(cmd) = body_cmd {
                            let body_list = ZshList {
                                sublist: ZshSublist {
                                    pipe: ZshPipe {
                                        cmd,
                                        next: None,
                                        lineno: lineno(),
                                        merge_stderr: false,
                                    },
                                    next: None,
                                    flags: SublistFlags::default(),
                                },
                                flags: ListFlags::default(),
                            };
                            lists.pop();
                            let funcdef = ZshCommand::FuncDef(ZshFuncDef {
                                names: names.clone(),
                                body: Box::new(ZshProgram {
                                    lists: vec![body_list],
                                }),
                                tracing: false,
                                keyword_form: false,
                                auto_call_args: None,
                                body_source: None,
                            });
                            let synthetic = ZshList {
                                sublist: ZshSublist {
                                    pipe: ZshPipe {
                                        cmd: funcdef,
                                        next: None,
                                        lineno: lineno(),
                                        merge_stderr: false,
                                    },
                                    next: None,
                                    flags: SublistFlags::default(),
                                },
                                flags: ListFlags::default(),
                            };
                            lists.push(synthetic);
                        }
                    }
                }
                // c:769-803 + c:644-682 — lists only chain across
                // explicit SEPER/AMPER/AMPERBANG. When par_list ended
                // WITHOUT a terminator, C's grammar says the list is
                // over: nested contexts (while-cond, brace bodies)
                // return to the caller with the dangling token (so
                // `while {false} {print no}` hands the second `{` to
                // par_while as the loop body), and the TOP level
                // (par_event, c:671-680) yyerrors — `{false} {print
                // no}` is `parse error near \`{'` in zsh. The funcdef
                // synthesis branch above manages its own following
                // tokens (`f() { body }` legitimately has INBRACE
                // right after the Simple), so it is exempt.
                if !was_detected && !terminated {
                    match tok() {
                        // End-of-input / lex error: loop top handles.
                        ENDINPUT | LEXERR => {}
                        // Construct closers and orphan terminators:
                        // the loop-top match already errors/breaks
                        // for these with the right diagnostics.
                        OUTBRACE_TOK | DSEMI | SEMIAMP | SEMIBAR | DONE | FI | ESAC | ZEND
                        | DOLOOP | ELSE | ELIF | THEN => {}
                        t if end_tokens.map_or(false, |e| e.contains(&t)) => {}
                        _ if end_tokens.is_some() => {
                            // Nested list context: C par_list just
                            // ends; the construct parser (par_while
                            // body dispatch, par_subsh closer check)
                            // deals with the token.
                            break;
                        }
                        offending => {
                            // Top level: C par_event yyerror(1) +
                            // errflag, c:671-682. Same tokstr
                            // injection as the None arm below so the
                            // "near `X'" tail survives punctuation
                            // tokens with no tokstr.
                            if crate::ported::lex::tokstr().is_none() {
                                let i = offending as usize;
                                if i < crate::ported::lex::tokstrings.len() {
                                    if let Some(s) = crate::ported::lex::tokstrings[i] {
                                        crate::ported::lex::set_tokstr(Some(s.to_string()));
                                    }
                                }
                            }
                            set_tok(LEXERR); // c:672
                            yyerror(1);
                            let noerrs_v = *crate::ported::utils::noerrs_lock().lock().unwrap();
                            if noerrs_v != 2 {
                                errflag.fetch_or(
                                    crate::ported::zsh_h::ERRFLAG_ERROR,
                                    Ordering::SeqCst,
                                );
                            }
                            break;
                        }
                    }
                }
            }
            None => {
                // c:Src/parse.c:644-645 par_event — `if (tok ==
                // ENDINPUT) return 0;`. End-of-input is NORMAL — no
                // diagnostic. The yyerror path at c:670-682 fires only
                // when par_sublist actually failed (the C `!r` branch).
                //
                // zshrs's previous fix here unconditionally called
                // yyerror on every None return, breaking legitimate
                // end-of-input scenarios like `(echo sub)` (par_list
                // returns None after the subshell parser consumes the
                // whole construct, leaving tok at ENDINPUT).
                if tok() == ENDINPUT {
                    break;
                }
                // c:Src/parse.c:671-680 par_event — par_sublist failed:
                // emit the canonical yyerror with the "near `X'" tail
                // derived from zshlextext/tokstr().
                //
                // c:Src/lex.c:1965 — `zshlextext = tokstrings[tok]`
                // is set DURING zshlex, before set_tok(LEXERR) here.
                // zshrs's zshlex doesn't update LEX_TOKSTR for
                // single-char punctuation tokens (OUTPAR/INPAR/etc.),
                // so by the time yyerror runs, tokstr() is None and
                // the tail "near `)'" is lost. Inject the current
                // tok's canonical text into LEX_TOKSTR here so the
                // C-faithful yyerror lookup finds it. Mirrors the
                // visible effect of C's zshlextext fallback.
                let already_flagged =
                    (errflag.load(Ordering::SeqCst) & crate::ported::zsh_h::ERRFLAG_ERROR) != 0;
                let offending_tok = tok();
                if crate::ported::lex::tokstr().is_none() {
                    let i = offending_tok as usize;
                    if i < crate::ported::lex::tokstrings.len() {
                        if let Some(s) = crate::ported::lex::tokstrings[i] {
                            crate::ported::lex::set_tokstr(Some(s.to_string()));
                        }
                    }
                }
                set_tok(LEXERR); // c:672
                yyerror(if already_flagged { 0 } else { 1 });
                // c:Src/parse.c:679-680 — `if (noerrs != 2) errflag |=
                // ERRFLAG_ERROR;`. C sets errflag explicitly after the
                // yyerror(1) print-only branch. Without this, the
                // caller (`execute_script_zsh_pipeline` here, `bin_eval`
                // for the parse_string path) can't distinguish "no
                // parse error" from "parse error already printed", so
                // $? stays at 0 after `eval ')foo'`.
                let noerrs_v = *crate::ported::utils::noerrs_lock().lock().unwrap();
                if noerrs_v != 2 {
                    errflag.fetch_or(crate::ported::zsh_h::ERRFLAG_ERROR, Ordering::SeqCst);
                }
                break;
            }
        }

        // c:Src/parse.c par_event — single-event (top-level, endtok ==
        // ENDINPUT) mode stops at the terminating top-level newline. The
        // SEPER par_list arm above left `tok` AT the newline-SEPER (not
        // consumed, LEX_ISNEWLIN > 0), so break before the loop-top
        // separator skip would `zshlex()` past it and read the next
        // line. A `;`-SEPER (LEX_ISNEWLIN <= 0) or `&` was consumed by
        // par_list and leaves a different token here, so chaining keeps
        // looping (same logical line). Multi-line compounds were already
        // fully consumed inside par_list, so their internal newlines
        // never reach this check.
        if single_event && tok() == SEPER && crate::ported::lex::LEX_ISNEWLIN.with(|c| c.get()) > 0
        {
            break;
        }
    }

    ZshProgram { lists }
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the ENVSTRING / ENVARRAY assignment arms that C handles inline inside
/// `par_simple` (c:1900-1998).
/// Parse an assignment
/// Parse an assignment word `NAME=value` or `NAME=(arr items)`.
/// Sub-routine of par_simple. The C source handles assignments
/// inline in par_simple via the ENVSTRING/ENVARRAY token paths
/// (parse.c:1842-2000ish); zshrs splits it out to a dedicated
/// helper for clarity.
fn parse_assign() -> Option<ZshAssign> {
    // Helper: locate the `=` that delimits NAME from VALUE — the scan
    // par_simple's ENVSTRING arm runs (c:Src/parse.c:1851-1865):
    //
    //     for (ptr = tokstr;
    //          *ptr && *ptr != Inbrack && *ptr != '=' && *ptr != '+';
    //          ptr++);
    //     if (*ptr == Inbrack) skipparens(Inbrack, Outbrack, &ptr);
    //     if (*ptr == '+') *ptr++ = '\0';
    //     if (*ptr == '=') { *ptr = '\0'; str = ptr + 1; }
    //     else equalsplit(tokstr, &str);
    //
    // Only the lexer's Inbrack/Outbrack TOKENS delimit the subscript, so a
    // quoted or backslashed bracket inside it is content. The previous
    // depth walk counted raw `[`/`(`/`{` as well, so a quoted one in the
    // key (`pc['\[']=…`, `pc['(']=…` — Functions/Prompts/prompt_clint_setup)
    // never returned to depth 0, the assignment was dropped and the next
    // token was a parse error. zshrs's lexer spells the assignment `=` as
    // the Equals token where C keeps it raw, so both spellings count.
    fn find_assign_equals(s: &str) -> Option<usize> {
        use crate::ported::zsh_h::{Inbrack, Outbrack};
        let is_eq = |c: char| c == '=' || c == Equals;
        // c:1851-1853
        let mut ptr = s
            .char_indices()
            .find(|&(_, c)| c == Inbrack || c == '+' || is_eq(c))
            .map_or(s.len(), |(i, _)| i);
        // c:1854 — `if (*ptr == Inbrack) skipparens(Inbrack, Outbrack, &ptr);`
        if s[ptr..].starts_with(Inbrack) {
            let mut cursor = &s[ptr..];
            crate::ported::utils::skipparens(Inbrack, Outbrack, &mut cursor);
            ptr = s.len() - cursor.len();
        }
        // c:1855-1857 — `+=`
        if s[ptr..].starts_with('+') {
            ptr += 1;
        }
        // c:1861-1863
        if s[ptr..].chars().next().is_some_and(is_eq) {
            return Some(ptr);
        }
        // c:1865 — `equalsplit(tokstr, &str)` (c:Src/utils.c:4133): the
        // first `=` anywhere.
        s.char_indices().find(|&(_, c)| is_eq(c)).map(|(i, _)| i)
    }

    let _ts_tokstr = tokstr()?;
    let tokstr = _ts_tokstr.as_str();

    // Parse name=value or name+=value.
    let (name, value_str, append) = if tok() == ENVARRAY {
        let (name, append) = if let Some(stripped) = tokstr.strip_suffix('+') {
            (stripped, true)
        } else {
            (tokstr, false)
        };
        (name.to_string(), String::new(), append)
    } else if let Some(pos) = find_assign_equals(tokstr) {
        let name_part = &tokstr[..pos];
        let (name, append) = if let Some(stripped) = name_part.strip_suffix('+') {
            (stripped, true)
        } else {
            (name_part, false)
        };
        (
            name.to_string(),
            tokstr[pos + Equals.len_utf8()..].to_string(),
            append,
        )
    } else if let Some(pos) = tokstr.find('=') {
        // Fallback to literal '=' for compatibility
        let name_part = &tokstr[..pos];
        let (name, append) = if let Some(stripped) = name_part.strip_suffix('+') {
            (stripped, true)
        } else {
            (name_part, false)
        };
        (name.to_string(), tokstr[pos + 1..].to_string(), append)
    } else {
        return None;
    };

    let value = if tok() == ENVARRAY {
        // Array assignment: name=(...)
        // c:Src/parse.c:1895 par_simple ENVARRAY arm:
        //   `int oldcmdpos = incmdpos; ... incmdpos = 0; ... zshlex();`
        // Reset incmdpos to false BEFORE the array body's first lex so
        // a leading `{...}` (brace expansion) doesn't trip the
        // empty-buf+incmdpos rule at lex.c:1141 that returns `{` as
        // STRING and lets the reswd_lookup promote it to INBRACE_TOK.
        let oldcmdpos = crate::ported::lex::incmdpos();
        crate::ported::lex::set_incmdpos(false);
        // c:Src/parse.c:2041-2046 — `intypeset = 0;` BEFORE reading
        // the array body, restored to the saved value after. Without
        // this, an element containing `=` (`typeset -a w=( VAR=1
        // sudo )`) re-triggers the lexer's intypeset assignment
        // detection and lexes `VAR=1` as ENVSTRING instead of a plain
        // STRING element — the body loop ends early on the non-STRING
        // token and the parser errors "near `)'".
        let old_intypeset = crate::ported::lex::intypeset();
        crate::ported::lex::set_intypeset(false);
        let mut elements = Vec::new();
        zshlex(); // skip past token

        // c:Src/parse.c:2043 par_nl_wordlist — read array elements until the
        // token is no longer a word/separator (the closing `)` ends it). zsh
        // imposes NO element-count limit; arrays grow dynamically. A former
        // `MAX_ARRAY_ELEMENTS = 10_000` cap here silently truncated (and
        // errored on) any larger literal — which broke loading `.zcompdump`
        // (`_comps`/`_lastcomp` hold tens of thousands of entries with
        // zsh-more-completions) and any big generated array. The loop
        // terminates on the closing paren via zshlex advancing each pass.
        while matches!(tok(), STRING_LEX | SEPER | NEWLIN) {
            if tok() == STRING_LEX {
                let _ts_s = crate::ported::lex::tokstr();
                if let Some(s) = _ts_s.as_deref() {
                    elements.push(s.to_string());
                }
            }
            zshlex();
        }
        // c:Src/parse.c — `incmdpos = oldcmdpos;` (restore at end of arm)
        crate::ported::lex::set_incmdpos(oldcmdpos);
        // c:Src/parse.c:2046 — `intypeset = 1;` (restore for any
        // follow-on `b=( … )` in `typeset a=(…) b=(…)`).
        crate::ported::lex::set_intypeset(old_intypeset);

        // The closing Outpar is consumed here. The outer par_simple
        // loop will then `zshlex()` past whatever follows (typically
        // a separator or the next word) — calling zshlex twice in
        // tandem (here AND in par_simple) over-advances and merges
        // a following `name() { … }` funcdef into the same Simple.
        // We only consume Outpar; let the caller handle the rest.
        // Without this guard `g=(o1); f() { :; }` parsed as one
        // Simple with assigns=[g] and words=["f()"] (one token).
        // c:Src/parse.c:1904-1905 / c:2048-2049 — `if (tok != OUTPAR)
        // YYERROR(oecused);`. The element loop stops at any other token, so
        // without this `x=(q()` (INOUTPAR) assigned `q` and ran on.
        if tok() != OUTPAR_TOK {
            yyerror(0);
            return None;
        }
        if tok() == OUTPAR_TOK {
            // Note: do NOT zshlex() here. par_simple's `lexer
            // .zshlex()` after `parse_assign` returns advances past
            // the Outpar onto the next significant token.
            //
            // Force `incmdpos=true` so the next zshlex() recognizes
            // a follow-up `b=(...)` / `b=val` as Envarray/Envstring.
            // The lexer flips incmdpos to false on bare Outpar (which
            // is correct for subshell-close context), but for an
            // array-assignment close more assigns/words may follow.
            set_incmdpos(true);
        }

        ZshAssignValue::Array(elements)
    } else {
        ZshAssignValue::Scalar(value_str)
    };

    Some(ZshAssign {
        name,
        value,
        append,
    })
}

/// Port of `par_redir` from `Src/parse.c:2229` — C decl `par_redir(int *rp, char *idstring)`. Rust fn `par_redir_with_id` is the AST variant carrying C's `char *idstring` parameter; `par_redir` at parse.rs:3096 is the NULL-idstring wrapper.
/// AST `par_redir` variant accepting an idstring for the
/// `{var}>file` brace-FD shape. C signature
/// `par_redir(int *rp, char *idstring)` (parse.c:2229). The
/// idstring is stored in the resulting ZshRedir.varid for the
/// executor to bind the named variable to the chosen fd.
fn par_redir_with_id(idstring: Option<&str>) -> Option<ZshRedir> {
    let varid: Option<String> = idstring.map(|s| s.to_string());
    let rtype = match tok() {
        OUTANG_TOK => REDIR_WRITE,
        OUTANGBANG => REDIR_WRITENOW,
        DOUTANG => REDIR_APP,
        DOUTANGBANG => REDIR_APPNOW,
        INANG_TOK => REDIR_READ,
        INOUTANG => REDIR_READWRITE,
        DINANG => REDIR_HEREDOC,
        DINANGDASH => REDIR_HEREDOCDASH,
        TRINANG => REDIR_HERESTR,
        INANGAMP => REDIR_MERGEIN,
        OUTANGAMP => REDIR_MERGEOUT,
        AMPOUTANG => REDIR_ERRWRITE,
        OUTANGAMPBANG => REDIR_ERRWRITENOW,
        DOUTANGAMP => REDIR_ERRAPP,
        DOUTANGAMPBANG => REDIR_ERRAPPNOW,
        _ => return None,
    };

    let fd = if tokfd() >= 0 {
        tokfd()
    } else if matches!(
        rtype,
        REDIR_READ
            | REDIR_READWRITE
            | REDIR_MERGEIN
            | REDIR_HEREDOC
            | REDIR_HEREDOCDASH
            | REDIR_HERESTR
    ) {
        0
    } else {
        1
    };

    // c:2234-2245 — save/restore incmdpos and nocorrect around the
    // zshlex that consumes the redir target word:
    //   oldcmdpos = incmdpos; incmdpos = 0;
    //   oldnc = nocorrect;
    //   if (tok != INANG && tok != INOUTANG) nocorrect = 1;
    //   ... zshlex; check tok; ...
    //   incmdpos = oldcmdpos; nocorrect = oldnc;
    // Without this, a redir target lexes in the parent's incmdpos
    // (re-promoting `{` / reswords) AND with parent nocorrect (so
    // spelling-correction wrongly runs inside `> $(cmd)` etc.).
    let oldcmdpos = incmdpos();
    set_incmdpos(false);
    let oldnc = nocorrect();
    let cur = tok();
    if cur != INANG_TOK && cur != INOUTANG {
        set_nocorrect(1);
    }
    // The operator's own lexeme, kept for the YYERROR path below — see the
    // note in the wordcode `par_redir` above for why C does not need it.
    let redir_op_text: Option<String> = {
        let i = cur as usize;
        if i < crate::ported::lex::tokstrings.len() {
            crate::ported::lex::tokstrings[i].map(|t| t.to_string())
        } else {
            None
        }
    };
    zshlex();

    let name = match tok() {
        STRING_LEX | ENVSTRING => {
            let n = tokstr().unwrap_or_default();
            // c:2244-2245 — restore incmdpos / nocorrect right after
            // the redir target word is confirmed, BEFORE the trailing
            // zshlex advances past it. The advance itself happens
            // below so REDIR_HEREDOC[DASH] can push onto HDOCS first
            // (matching the wordcode variant at parse.rs:6894-6908) —
            // otherwise the NEWLIN drained by that zshlex sees an
            // empty HDOCS list and gethere never collects the body.
            set_incmdpos(oldcmdpos);
            set_nocorrect(oldnc);
            n
        }
        _ => {
            set_incmdpos(oldcmdpos);
            set_nocorrect(oldnc);
            // c:2243 `YYERROR(ecused)` — see the note on the wordcode arm
            // above; the message is yyerror's "parse error near `X'", not a
            // custom one.
            if crate::ported::lex::tokstr().is_none() {
                crate::ported::lex::set_tokstr(redir_op_text);
            }
            set_tok(LEXERR);
            return None;
        }
    };

    // Heredoc terminator capture. C parse.c:2254-2317 par_redir builds
    // a `struct heredocs` entry here for REDIR_HEREDOC[DASH]. zshrs
    // pushes onto HDOCS (canonical C linked list, c:2290-2296) AND
    // onto LEX_HEREDOCS (Rust-only AST-glue Vec carrying parsed-out
    // terminator/strip_tabs/quoted metadata for downstream AST
    // consumers). Quoted terminators (`<<'EOF'` / `<<"EOF"` / `<<\EOF`)
    // disable expansion in the body — Snull `\u{e19d}` marks single-quote,
    // Dnull `\u{e19e}` marks double-quote, Bnull `\u{e19f}` marks
    // backslash-escaped chars.
    let heredoc_idx = if matches!(rtype, REDIR_HEREDOC | REDIR_HEREDOCDASH) {
        let strip_tabs = rtype == REDIR_HEREDOCDASH;
        let quoted = name.contains('\u{e19d}')
            || name.contains('\u{e19e}')
            || name.contains('\u{e19f}')
            || name.starts_with('\'')
            || name.starts_with('"');
        let term = name
            .chars()
            .filter(|c| {
                *c != '\'' && *c != '"' && *c != '\u{e19d}' && *c != '\u{e19e}' && *c != '\u{e19f}'
            })
            .collect::<String>();
        // c:2290-2296 — `for (hd = &hdocs; *hd; hd = &(*hd)->next);
        //                 *hd = zalloc(sizeof(struct heredocs));
        //                 (*hd)->next = NULL;
        //                 (*hd)->type = htype;
        //                 (*hd)->pc = r;
        //                 (*hd)->str = tokstr;`
        // AST path has no wordcode pc to patch; use -1 sentinel so the
        // inline NEWLIN walk in `zshlex()` skips the setheredoc call.
        HDOCS.with_borrow_mut(|head| {
            let mut cur = head;
            while cur.is_some() {
                cur = &mut cur.as_mut().unwrap().next; // c:2290
            }
            *cur = Some(Box::new(crate::ported::zsh_h::heredocs {
                // c:2292-2296
                next: None,
                typ: rtype,
                pc: -1,
                str: Some(name.clone()),
            }));
        });
        // zshrs-only: push parallel AST-glue entry onto LEX_HEREDOCS.
        let idx = LEX_HEREDOCS.with_borrow_mut(|v| {
            v.push(HereDoc {
                terminator: term,
                strip_tabs,
                content: String::new(),
                quoted,
                processed: false,
            });
            v.len() - 1
        });
        Some(idx)
    } else {
        None
    };

    // c:2298 (heredoc) / c:2322 (other redirs) — final zshlex() advance
    // past the redir target word. MUST run after the HDOCS push above
    // so the heredoc-drain inside this zshlex sees the new entry. For
    // non-heredoc forms the order is irrelevant; consolidating to a
    // single tail-call here matches the wordcode variant.
    zshlex();

    Some(ZshRedir {
        rtype,
        fd,
        name,
        heredoc: None,
        varid,
        heredoc_idx,
    })
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the `if (tok == DINPAR)` c-style-for branch that C handles inline
/// inside `par_for` (c:1096-1140).
/// Parse C-style for loop: for (( init; cond; step ))
/// Parse the c-style `for ((init; cond; incr)) do BODY done`.
/// Inner branch of zsh/Src/parse.c:1100-1140 inside par_for.
/// Recognized when the token after FOR is DINPAR (the `((`
/// detected by gettok via dbparens setup).
fn parse_for_cstyle() -> Option<ZshCommand> {
    // We're at (( (Dinpar None) - the opening ((
    // Lexer returns:
    //   Dinpar None     - opening ((
    //   Dinpar "init"   - init expression, semicolon consumed
    //   Dinpar "cond"   - cond expression, semicolon consumed
    //   Doutpar "step"  - step expression, closing )) consumed
    zshlex(); // Get init: Dinpar "i=0"

    if tok() != DINPAR {
        set_tok(LEXERR); // c:1100 YYERRORV(oecused)
        return None;
    }
    let init = tokstr().unwrap_or_default();

    zshlex(); // Get cond: Dinpar "i<10"

    if tok() != DINPAR {
        set_tok(LEXERR); // c:1104 YYERRORV(oecused)
        return None;
    }
    let cond = tokstr().unwrap_or_default();

    zshlex(); // Get step: Doutpar "i++"

    if tok() != DOUTPAR {
        set_tok(LEXERR); // c:1108 YYERRORV(oecused)
        return None;
    }
    let step = tokstr().unwrap_or_default();

    // c:1110 — `infor = 0;` before the body opener. The companion
    // `incmdpos = 1;` at c:1111 is intentionally skipped here for
    // the same reason c:1094's `incmdpos = 0;` is skipped in
    // par_for above — zshrs doesn't mirror the full
    // incmdpos state-machine inline.
    set_infor(0); // c:1110
    zshlex(); // Move past ))

    skip_separators();
    let body = parse_loop_body(false, false)?;

    Some(ZshCommand::For(ZshFor {
        var: String::new(),
        list: ForList::CStyle { init, cond, step },
        body: Box::new(body),
        is_select: false,
    }))
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the SELECT arm of `par_for` (c:1087; `par_cmd` routes SELECT there at
/// c:983-985), which C does not split into its own function.
/// Parse select loop (same syntax as for)
/// Parse `select NAME in WORDS; do BODY; done`. Same shape as
/// `for NAME in WORDS; do ...` but with menu-prompt semantics in
/// the executor. C equivalent: the SELECT case in par_for at
/// parse.c:1087-1207 (selects share parser flow with foreach).
fn parse_select() -> Option<ZshCommand> {
    // `select` shares par_for's grammar (var, words, body) but the
    // compile path is different (interactive prompt loop).
    match par_for()? {
        ZshCommand::For(mut f) => {
            f.is_select = true;
            Some(ZshCommand::For(f))
        }
        other => Some(other),
    }
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the DOLOOP / INBRACE / short-form loop-body ladder that C repeats
/// inline in `par_for` (c:1170-1194), `par_while` (c:1536-1553) and
/// `par_repeat` (c:1586-1602).
/// Parse loop body (do...done, {...}, or shortloop)
/// Parse the `do BODY done` body of a for/while/until/select/
/// repeat loop. Direct equivalent of zsh's parse.c handling
/// inside the loop builders — they all consume DOLOOP, parse a
/// list until DONE, and return the list. The `foreach_style`
/// flag signals foreach (where short-form `for NAME in WORDS;
/// CMD` may skip do/done) vs c-style (which always requires
/// do/done).
///
/// `is_repeat` widens the SHORTLOOPS gate so `SHORTREPEAT` also
/// unlocks the short form for `repeat N CMD` (per c:1600
/// `unset(SHORTLOOPS) && unset(SHORTREPEAT)`).
fn parse_loop_body(foreach_style: bool, is_repeat: bool) -> Option<ZshProgram> {
    // c:1180-1194 — body dispatch order per par_for:
    //   `do ... done` (DOLOOP) — primary form.
    //   `{ ... }`   (INBRACE) — alternate.
    //   csh/CSHJUNKIELOOPS — terminator is `end`.
    //   else if (unset(SHORTLOOPS)) — YYERROR.
    //   else — short form (single command).
    if tok() == DOLOOP {
        zshlex();
        // Body parse must declare DONE as an end-token so the
        // parse_program_until top-level orphan-DONE guard doesn't
        // mis-fire on the legitimate loop terminator.
        let body = parse_program_until(Some(&[DONE]), false);
        // c:Src/parse.c:1182-1183 / :1535-1536 / :1597-1598 —
        // `if (tok != DONE) YYERRORV(oecused);`. zshrs previously
        // silently accepted EOF as a substitute for `done`, so
        // `for i in a; do echo hi; don` ran the loop with `don` as
        // a command (which then failed "command not found") instead
        // of erroring at parse time. Bug #403, #404.
        if tok() != DONE {
            set_tok(LEXERR); // c:1174 YYERRORV(oecused)
            return None;
        }
        // c:1175 / c:1537 / c:1586 — `incmdpos = 0; zshlex();`: the word after
        // the loop closer is not in command position, so under IGNORE_BRACES a
        // `}` there is an ordinary word and `{ for i in 1; do :; done }` is a
        // parse error, as in zsh.
        set_incmdpos(false);
        zshlex();
        Some(body)
    } else if tok() == INBRACE_TOK {
        zshlex();
        let body = parse_program_until(Some(&[OUTBRACE_TOK]), false);
        // c:Src/parse.c:1186 / :1539 — `if (tok != OUTBRACE) YYERRORV`.
        if tok() != OUTBRACE_TOK {
            set_tok(LEXERR); // c:87 YYERRORV(oecused) — no own message
            return None;
        }
        // c:1182 / c:1544 — the brace form clears incmdpos the same way.
        set_incmdpos(false);
        zshlex();
        Some(body)
    } else if foreach_style || isset(CSHJUNKIELOOPS) {
        // c:1184 / 1546 / 1595 — `else if (csh || isset(CSHJUNKIELOOPS))`.
        let body = parse_program_until(Some(&[ZEND]), false);
        // c:1190 / 1548 — `if (tok != ZEND) YYERRORV`.
        if tok() != ZEND {
            set_tok(LEXERR); // c:1187 YYERRORV(oecused)
            return None;
        }
        zshlex();
        Some(body)
    } else {
        // c:1190 / 1474 / 1551 / 1600 — short-form gate. C bails
        // with YYERROR when `unset(SHORTLOOPS) && (!is_repeat ||
        // unset(SHORTREPEAT))`. zshrs's option machinery isn't
        // initialised at parse-test time (no `init_main` →
        // `install_emulation_defaults`), so a strict port here
        // body. parse_init seeds SHORTLOOPS=on mirroring C
        // `install_emulation_defaults`, so this fires only when a
        // script explicitly disabled the option.
        if unset(SHORTLOOPS) && (!is_repeat || unset(SHORTREPEAT)) {
            // c:Src/parse.c:1190 / :1474 / :1551 / :1600 —
            // `YYERRORV(oecused)` only sets `tok = LEXERR`; the
            // DIAGNOSTIC is emitted upstream by par_list's
            // `if (!r) { ... yyerror(1); ... }` (c:670-677), which
            // prints `parse error near \`<zshlextext>'`. zshrs
            // invented its own wording, so `unsetopt shortloops;
            // eval 'for f in a; print $f'` said "short loop form
            // requires SHORTLOOPS option" where zsh says
            // "parse error near \`print'" (E01options.ztst:74).
            // c:87-88 — `#define YYERRORV(O) { tok = LEXERR; ecused =
            // (O); return; }`. The macro sets the token and RETURNS;
            // the single diagnostic comes from the caller
            // (par_list's `if (!r) { ... yyerror(1); ... }`, c:670-677
            // — mirrored by parse_program_until's LEXERR arm). Calling
            // yyerror here as well printed the message twice.
            set_tok(LEXERR); // c:87 `tok = LEXERR`
            return None;
        }
        // c:Src/parse.c:1604 / :1474 / :1551 — short form calls
        // par_save_list1 → par_list1 → par_sublist, which parses
        // ONE sublist and leaves the trailing SEPER untouched for
        // the outer par_list to consume. zshrs previously routed
        // through par_list() which consumes the trailing `;`/`\n`
        // separator — that swallowed the separator between the
        // loop's body command and the next outer command, so
        // `repeat 2 print x; print y` parsed as repeat-then-eof
        // and par_cmd's post-compound STRING_LEX guard at parse.rs
        // line 1170 fired "parse error near `print'". Bug #593.
        par_list1().map(|sublist| ZshProgram {
            lists: vec![ZshList {
                sublist,
                flags: ListFlags::default(),
            }],
        })
    }
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the anonymous-function shape that C handles inline in `par_simple`
/// (c:2016-2028) via the INOUTPAR test with no preceding name.
/// `() { body } arg1 arg2 …` — anonymous function. Defines a fresh
/// function named `_zshrs_anon_N`, invokes it with the args, and the
/// body runs with positional params set. Implemented as the desugared
/// pair (FuncDef + Simple call) so the compile path doesn't need new
/// machinery.
/// Parse an anonymous function definition `() { BODY }` followed
/// by call args. zsh treats `() { echo hi; } a b c` as defining
/// and immediately calling an anon fn with args a/b/c. C
/// equivalent: the INOUTPAR shape in par_simple at parse.c:1836+
/// triggers an anon-funcdef path.
fn parse_anon_funcdef() -> Option<ZshCommand> {
    // Track the byte position just past the `()` / most-recent separator so an
    // UNBRACED body's raw text can be sliced for `functions` rendering. pos()
    // AFTER a zshlex is already past the next token (one-token lookahead), so
    // body_start must be recorded BEFORE each advance. Mirrors the braced
    // path's body_start-before-zshlex capture (parse.rs:2484).
    let mut body_mark = crate::funcdef_capture::body_mark_begin();
    zshlex(); // skip ()
    while tok() == SEPER || tok() == NEWLIN {
        crate::funcdef_capture::body_mark_restart(&mut body_mark);
        zshlex();
    }
    // c:Src/parse.c:1728-1748 — after `()` (and any separators, skipped at
    // c:1720), the body is either a braced `{ … }` (par_list) OR, with
    // SHORTLOOPS set (the default), a single UNBRACED command (par_list1):
    // `() print hi` runs an anon fn whose body is `print hi`, and
    // `f() () print hi` nests one as another function's body. A bodyless `()`
    // is a parse error in zsh ("parse error near `()'"), which par_cmd()
    // produces naturally when the next token can't start a command (`}`, EOF).
    let (body, body_source) = if tok() != INBRACE_TOK {
        // c:2110 — no SHORTLOOPS gate on the `name ()` / `()` body (see
        // parse_inline_funcdef).
        // c:2114 — `par_cmd(&c, argc == 0)`: for an anonymous function
        // zsh_construct is set, so a `( … )` / `{ … }` body leaves the NEXT
        // word out of command position (c:1632, c:2118-2128) and
        // `() (cat $1 $2) <(print a) =(print b)` reads its arguments as words.
        // Slice the raw body text (body_start was captured before the body
        // token was lexed, above) so `functions`/`typeset -f` can render it:
        // fusevm shfuncs carry no C-shaped Eprog, so hashtable.rs:1397-1414
        // renders from this raw `body` string, not getpermtext. Without it the
        // body listed as `f () { }` (empty).
        let cmd = par_cmd(true)?;
        let body_source = crate::funcdef_capture::body_text(body_mark)
            .map(|s| {
                s.trim()
                    .trim_end_matches(|c: char| c == ';' || c == '\n' || c.is_whitespace())
                    .to_string()
            })
            .filter(|s| !s.is_empty());
        // c:Src/parse.c par_funcdef bakes alias expansion into the wordcode; see
        // vm_helper::funcdef_note_resolved_body.
        crate::vm_helper::funcdef_note_resolved_body(body_source.as_deref());
        let list = ZshList {
            sublist: ZshSublist {
                pipe: ZshPipe {
                    cmd,
                    next: None,
                    lineno: lineno(),
                    merge_stderr: false,
                },
                next: None,
                flags: SublistFlags::default(),
            },
            flags: ListFlags::default(),
        };
        (ZshProgram { lists: vec![list] }, body_source)
    } else {
        zshlex(); // skip {
                  // c:Src/parse.c:par_subsh — anon `() { … }` body must terminate at
                  // OUTBRACE_TOK. Pass it as the explicit end-token so the inner
                  // parse stops cleanly at `}` rather than hitting the top-level
                  // stray-`}` arm (#168). Bug #167 family.
        let body = parse_program_until(Some(&[OUTBRACE_TOK]), false);
        // c:Src/parse.c:1733-1737 — same `if (tok != OUTBRACE) YYERRORV`
        // gate as the named-funcdef path. Bug #405 sibling.
        if tok() != OUTBRACE_TOK {
            set_tok(LEXERR); // c:87 YYERRORV(oecused) — no own message
            return None;
        }
        // c:2102-2105 — `if (argc == 0) { /* Anonymous function, possibly
        // with arguments */ incmdpos = 0; }`: the words after `}` are the
        // function's arguments, so `() { echo $1 } (y|z)*` lexes `(y|z)*` as
        // a glob word rather than a subshell.
        set_incmdpos(false);
        zshlex();
        (body, None)
    };
    // c:2148-2167 — collect trailing args AND redirections, interleaved in any
    // order, until a separator. zsh's anon-fn form `() { body } a b c` runs
    // body with $1=a, $2=b, $3=c; redirs apply to that invocation:
    // `() { read v; print $1 $v } <input1 Shirley >output1 dude`
    // (c:Src/parse.c par_simple — the anon function is a simple command
    // whose words and redirs follow the body in any order). The previous
    // port collected ONLY leading STRING args here and left redirs to
    // par_cmd's trailing loop, so an arg AFTER a redir (`<in arg`) was
    // never reached and hit par_cmd's "parse error near `<arg>'" gate.
    let mut args = Vec::new();
    let mut redirs: Vec<ZshRedir> = Vec::new();
    loop {
        let t = tok();
        if t == STRING_LEX {
            if let Some(s) = tokstr() {
                args.push(s);
            }
            zshlex();
        } else if IS_REDIROP(t) {
            match par_redir() {
                Some(r) => redirs.push(r),
                None => break,
            }
        } else {
            break;
        }
    }

    // Generate a unique name. Module-level static would be cleaner but
    // a thread-local atomic is enough — anonymous functions are
    // ephemeral and the name isn't user-visible.
    static ANON_COUNTER: AtomicUsize = AtomicUsize::new(0);
    let n = ANON_COUNTER.fetch_add(1, Ordering::Relaxed);
    let name = format!("_zshrs_anon_{}", n);
    let funcdef = ZshCommand::FuncDef(ZshFuncDef {
        names: vec![name],
        body: Box::new(body),
        tracing: false,
        keyword_form: false,
        auto_call_args: Some(args),
        body_source,
    });
    // Wrap in Redirected so the redirs bracket the single invocation
    // (compile_zsh.rs:929 wraps the body in a WithRedirectsBegin/End
    // scope for Redirected(FuncDef, …)). par_cmd's trailing-redir loop
    // then finds none and returns this node unwrapped.
    if redirs.is_empty() {
        Some(funcdef)
    } else {
        Some(ZshCommand::Redirected(Box::new(funcdef), redirs))
    }
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the `case INBRACE:` arm of `par_cmd` (c:1013-1019), which C inlines as
/// `cmdpush(CS_CURSH); par_subsh(cmplx, 1); cmdpop();`.
/// Parse {...} cursh
/// Parse a current-shell brace block `{ BODY }`. C source
/// par_cmd at parse.c:958-1085 handles Inbrace → emit WC_CURSH
/// and recurses into the list. zshrs's parse_cursh extracts that
/// arm into a dedicated method.
fn parse_cursh(zsh_construct: bool) -> Option<ZshCommand> {
    zshlex(); // skip {
              // c:Src/parse.c:par_subsh — pass OUTBRACE_TOK as the explicit
              // body terminator so the inner parse stops cleanly at `}` rather
              // than falling through the top-level `OUTBRACE_TOK if
              // end_tokens.is_none()` arm (which errors on stray `}` per bug
              // #168). Bug #167 in docs/BUGS.md.
    let prog = parse_program_until(Some(&[OUTBRACE_TOK]), false);

    // c:Src/parse.c:par_subsh — `{ … }` requires a matching `}`.
    // C errors via YYERRORV when the body parse returns without
    // seeing OUTBRACE_TOK (parse.c:1623 inbrack check). zshrs's
    // previous behavior silently returned `Cursh(prog)` and ran the
    // body as if the braces were absent. Bug #167 in docs/BUGS.md.
    if tok() != OUTBRACE_TOK {
        // c:1630-1631 — `YYERRORV(oecused)`: flag LEXERR and let
        // par_event's yyerror name `zshlextext`, the last token lexed
        // (`{ print` → near `print', `{ print;` → near `;').
        set_tok(LEXERR); // c:87 `tok = LEXERR`
        return None;
    }
    // Check for { ... } always { ... }. Direct port of zsh's
    // par_subsh at parse.c:1612-1660 — note the two `incmdpos = 1`
    // forces (parse.c:1632, 1637): after consuming the closing
    // Outbrace AND after matching the `always` keyword, the parser
    // explicitly resets command position so the next `{` lexes as
    // Inbrace. Without these resets the lexer's String-clears-cmdpos
    // rule (lex.rs:976-983) leaves the second `{` in word position,
    // turning `always { ... }` into a Simple `{` `echo` … and the
    // try/always pairing is silently lost.
    {
        set_incmdpos(!zsh_construct); // parse.c:1632 incmdpos = !zsh_construct
        zshlex();

        // Check for 'always'
        if tok() == STRING_LEX {
            let s = tokstr();
            if s.map(|s| s == "always").unwrap_or(false) {
                set_incmdpos(true); // parse.c:1637 incmdpos = 1
                zshlex();
                skip_separators();

                // c:1643-1644 — `if (tok != INBRACE) YYERRORV(oecused);`
                if tok() != INBRACE_TOK {
                    set_tok(LEXERR); // c:87 `tok = LEXERR`
                    return None;
                }
                zshlex();
                // c:Src/parse.c — always-clause body terminates at
                // OUTBRACE_TOK. Bug #167/#168 family.
                let always = parse_program_until(Some(&[OUTBRACE_TOK]), false);
                set_incmdpos(true); // c:1653 `incmdpos = 1;`
                // c:1655-1656 — `if (tok != OUTBRACE) YYERRORV(oecused);`
                if tok() != OUTBRACE_TOK {
                    set_tok(LEXERR); // c:87 `tok = LEXERR`
                    return None;
                }
                zshlex();
                return Some(ZshCommand::Try(ZshTry {
                    try_block: Box::new(prog),
                    always: Box::new(always),
                }));
            }
        }
    }

    Some(ZshCommand::Cursh(Box::new(prog)))
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the `NAME () { ... }` funcdef shape that C handles inline in
/// `par_simple` (c:2016-2028) after the INOUTPAR token.
/// Parse inline function definition: name() { ... }
/// Parse the inline form `NAME () { BODY }` (POSIX-style funcdef
/// without the `function` keyword). The name has already been
/// consumed and pushed by par_simple before this method fires.
/// C source: handled inline in par_simple's INOUTPAR-after-name
/// arm (parse.c:1836-2228).
fn parse_inline_funcdef(names: Vec<String>) -> Option<ZshCommand> {
    // !!! DASH-STRICT GATE (no C counterpart) !!! dash's parser refuses a
    // function named after a special builtin or a non-identifier
    // ("Syntax error: Bad function name"); zsh accepts both.
    if crate::dash_mode::dash_strict()
        && names.iter().any(|n| crate::dash_mode::dash_bad_function_name(n))
    {
        zerr("Syntax error: Bad function name");
        set_tok(LEXERR);
        return None;
    }
    // par_simple's STRING loop left `incmdpos = 0`; the funcdef body
    // `{ ... }` requires `incmdpos = 1` so the lexer recognises `{`
    // as INBRACE_TOK (current-shell block opener) instead of a
    // literal `{` STRING. Without this, `myfunc() { echo body }`
    // parsed the body as the single STRING `"{"`, then `echo body`
    // fell out at top level. Mirrors the C path where par_cmd's
    // dispatcher (parse.c:958) is called with `incmdpos = 1` for
    // the funcdef body.
    set_incmdpos(true);
    // Track the byte position just past `()` / the most-recent separator, so an
    // UNBRACED short body (`f() cmd`) can be sliced for `functions` rendering.
    // pos() AFTER a zshlex is already past the next token (one-token
    // lookahead), so record it BEFORE each advance (mirrors parse.rs:2484).
    let mut body_mark = crate::funcdef_capture::body_mark_begin();
    // Skip ()
    if tok() == INOUTPAR {
        zshlex();
    }

    while tok() == SEPER || tok() == NEWLIN {
        crate::funcdef_capture::body_mark_restart(&mut body_mark);
        zshlex();
    }

    // Parse body
    if tok() == INBRACE_TOK {
        // Same body_start-before-zshlex fix as par_funcdef.
        crate::funcdef_capture::body_mark_restart(&mut body_mark);
        zshlex();
        // c:Src/parse.c — inline funcdef body terminates at OUTBRACE_TOK.
        // Explicit end-token keeps the inner parse from hitting the
        // top-level stray-`}` arm (#168). Bug #167 family.
        let body = parse_program_until(Some(&[OUTBRACE_TOK]), false);
        // c:Src/parse.c:1733-1737 — `if (tok != OUTBRACE) { cmdpop();
        // lineno += oldlineno; ecnpats = onp; ecssub = oecssub;
        // YYERRORV(oecused); }`. Without this gate, `f() { echo hi`
        // silently registered as a complete fn with body `echo hi`.
        // Bug #405.
        if tok() != OUTBRACE_TOK {
            set_tok(LEXERR); // c:87 YYERRORV(oecused) — no own message
            return None;
        }
        // Slice THROUGH pos() (not `pos()-1`). pos() sits just past the
        // funcdef `}` and any trailing whitespace/newline the lexer
        // consumed, so `[body_start, pos())` always contains the funcdef
        // `}`. Using `pos()-1` landed ON the `}` at end-of-input (no
        // trailing separator) and thus EXCLUDED it, so the subsequent
        // `strip_suffix('}')` chopped a legitimate inner `}` instead —
        // corrupting any body ending in a balanced `} always { ... }`
        // into `par_subsh: 'always' block missing }` on the `.zwc`
        // source path (getpermtext re-emits the file with no trailing
        // newline, so the last funcdef `}` sits at EOF). Bug #642.
        let body_source = crate::funcdef_capture::body_text(body_mark)
            .map(|s| {
                // The slice now always ends with the funcdef `}` (plus
                // optional trailing whitespace). Trim, strip that single
                // closing brace, then drop the structural separator
                // (`;`/`\n`) that preceded it — C zsh's getpermtext emits
                // each command without the trailing `;`/`\n`.
                let t = s.trim();
                // Strip the statement SEPARATOR that followed the funcdef
                // `}` FIRST — for `name() { body }; next` the slice ends in
                // `};`, so stripping the brace before the `;` left the `}`
                // stranded (`${functions[name]}` → `body }`, then re-parsed
                // to a `parse error near '}'`). Order: trailing separators →
                // closing brace → the body's own last-statement separator.
                let t = t.trim_end_matches(|c: char| c == ';' || c == '\n' || c.is_whitespace());
                let t = t.strip_suffix('}').unwrap_or(t).trim_end();
                let t = t
                    .trim_end_matches(|c: char| c == ';' || c == '\n')
                    .trim_end();
                t.to_string()
            })
            .filter(|s| !s.is_empty());
        // c:Src/parse.c par_funcdef bakes alias expansion into the wordcode; see
        // vm_helper::funcdef_note_resolved_body.
        crate::vm_helper::funcdef_note_resolved_body(body_source.as_deref());
        zshlex();
        Some(ZshCommand::FuncDef(ZshFuncDef {
            names,
            body: Box::new(body),
            tracing: false,
            keyword_form: false,
            auto_call_args: None,
            body_source,
        }))
    } else {
        // c:Src/parse.c:2110 — the `name ()` form (par_simple) takes ANY
        // command as body via `par_cmd(&c, argc == 0)` with NO SHORTLOOPS
        // gate (the gate at c:1742 belongs to the `function` keyword path,
        // par_funcdef). `f() ( echo x )` is valid under `emulate sh`/`ksh`.
        // verified: zsh -fc 'emulate sh; f() ( echo sub ); f' -> sub
        //
        // !!! BASH-MODE (no C counterpart) !!! bash's grammar requires a
        // COMPOUND command body: `f() echo hi` is a syntax error there.
        if crate::dash_mode::bash_mode() && tok() == STRING_LEX {
            set_tok(LEXERR);
            return None;
        }
        // Slice the raw short-body text (unbraced_body_start was captured
        // before the body token was lexed, above) so `functions`/`typeset -f`
        // can list it (fusevm shfuncs render from this raw `body`, not
        // getpermtext — hashtable.rs:1397). Without it `f() print x` listed as
        // `f () { }` (empty).
        match par_cmd(false) {
            Some(cmd) => {
                let body_source = crate::funcdef_capture::body_text(body_mark)
                    .map(|s| {
                        s.trim()
                            .trim_end_matches(|c: char| c == ';' || c == '\n' || c.is_whitespace())
                            .to_string()
                    })
                    .filter(|s| !s.is_empty());
                // c:Src/parse.c par_funcdef bakes alias expansion into the wordcode; see
                // vm_helper::funcdef_note_resolved_body.
                crate::vm_helper::funcdef_note_resolved_body(body_source.as_deref());
                let list = ZshList {
                    sublist: ZshSublist {
                        pipe: ZshPipe {
                            cmd,
                            next: None,
                            // c:Src/parse.c:2112 — `(void)ecadd(WCB_PIPE(
                            // WC_PIPE_END, 0));`. The BRACELESS short-body
                            // form (`f() cmd`) hand-builds its pipe wordcode
                            // with a line number of literal 0, unlike
                            // `par_pline` (c:944) which stores `toklineno+1`.
                            // `execpline2`'s guard (c:2056 `… &&
                            // WC_PIPE_LINENO(pcode)`) then never fires, so the
                            // body runs with the CALLER's `lineno` still in
                            // place — which is why `f() g; g() :; functions -t
                            // f; f` traces `+f:4> g` (the call site's line) and
                            // not the body's own. E02xtrace.ztst pins this
                            // (its own comment calls the 4 "incorrect", but it
                            // is what zsh does).
                            lineno: 0,
                            merge_stderr: false,
                        },
                        next: None,
                        flags: SublistFlags::default(),
                    },
                    flags: ListFlags::default(),
                };
                Some(ZshCommand::FuncDef(ZshFuncDef {
                    names,
                    body: Box::new(ZshProgram { lists: vec![list] }),
                    tracing: false,
                    keyword_form: false,
                    auto_call_args: None,
                    body_source,
                }))
            }
            // c:2114-2117 — `if (!par_cmd(&c, argc == 0)) { cmdpop();
            // YYERROR(oecused); }`: `f()` with no body is a syntax error.
            // The bare `None` never flagged LEXERR, so nothing reported it
            // and the script ran on with status 0. c:2071 `lineno = 0;` is
            // never undone on this path (only the brace arm's c:2097 adds
            // `oldlineno` back), so the diagnostic carries no line number.
            //
            // That holds only when par_cmd itself returns 0 (nothing
            // parsed: `f()` at end of input). A compound body that fails
            // INSIDE (`f() ( :`, `f() if`) YYERRORs in its own parser while
            // par_cmd still returns 1 (c:958-1060 `break`s after every
            // compound), so C runs on to c:2172 `lineno += oldlineno` and
            // the message keeps its line. A sub-construct failure is the
            // one that already left `tok == LEXERR`.
            None => {
                if tok() != LEXERR {
                    set_lineno(0);
                }
                set_tok(LEXERR);
                None
            }
        }
    }
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the entry alias onto the AST cond ladder; C enters at `par_cond`
/// (c:2409) directly.
/// Parse conditional expression
/// Top of `[[ ]]` cond-expression parsing — entry to recursive
/// descent (or → and → not → primary). Direct port of zsh's
/// par_cond_1 at parse.c:2434-2475.
fn parse_cond_expr() -> Option<ZshCond> {
    parse_cond_or()
}

/// Port of `par_cond` from `Src/parse.c:2409` — C decl `par_cond(void)`. Rust fn `parse_cond_or` is the AST variant: C's `cond : cond_1 [ DBAR { SEPER } cond ]` production, building `ZshCond::Or`.
/// Cond-expression `||` level. C: inside par_cond_1 at
/// parse.c:2434-2475 (the `cond_or` ladder).
fn parse_cond_or() -> Option<ZshCond> {
    let left = parse_cond_and()?;
    skip_cond_separators();

    if tok() == DBAR {
        zshlex();
        skip_cond_separators();
        parse_cond_or().map(|right| ZshCond::Or(Box::new(left), Box::new(right)))
    } else {
        Some(left)
    }
}

/// Port of `par_cond_1` from `Src/parse.c:2434` — C decl `par_cond_1(void)`. Rust fn `parse_cond_and` is the AST variant: C's `cond_1 : cond_2 [ DAMPER { SEPER } cond_1 ]` production, building `ZshCond::And`.
/// Cond-expression `&&` level. C: par_cond_2 at parse.c:2476-2625.
fn parse_cond_and() -> Option<ZshCond> {
    let left = parse_cond_not()?;
    skip_cond_separators();

    if tok() == DAMPER {
        zshlex();
        skip_cond_separators();
        parse_cond_and().map(|right| ZshCond::And(Box::new(left), Box::new(right)))
    } else {
        Some(left)
    }
}

/// `static FuncDump dumps;` from `Src/parse.c:3652` — head of the
/// loaded-`.zwc` linked list. C walks `dumps`/`p->next` directly;
/// the Rust port uses a `Mutex<Vec<funcdump>>` indexed by filename
/// so refcount ops can find an entry without raw-pointer compare.
pub static DUMPS: std::sync::Mutex<Vec<funcdump>> = std::sync::Mutex::new(Vec::new());

/// Port of `par_cond_2` from `Src/parse.c:2476` — C decl `par_cond_2(void)`. Rust fn `parse_cond_not` is the AST variant, BANG and INPAR arms (c:2528-2547); the STRING arms are split out into `parse_cond_primary`.
/// Cond-expression `!` negation level. C: handled inside
/// par_cond_2 at parse.c:2476-2625 via the Bang token check.
fn parse_cond_not() -> Option<ZshCond> {
    skip_cond_separators();

    // ! can be either BANG_TOK or String "!"
    let is_not =
        tok() == BANG_TOK || (tok() == STRING_LEX && tokstr().map(|s| s == "!").unwrap_or(false));
    if is_not {
        zshlex();
        let inner = parse_cond_not()?;
        return Some(ZshCond::Not(Box::new(inner)));
    }

    if tok() == INPAR_TOK {
        zshlex();
        skip_cond_separators();
        // c:2534-2547 par_cond_2 INPAR branch — an empty body
        // `[[ ( ) ]]` reaches par_cond_2 with tok=OUTPAR, which the
        // lexer produced from gettok with no tokstr, so c:2560 YYERRORs
        // and yyerror names the token from `tokstrings[OUTPAR]`: zsh
        // says "parse error near `)'". parse_cond_primary's `_` arm
        // returns None for exactly that case, and par_cond's
        // `tok != DOUTBRACK` arm runs yyerror while OUTPAR is still
        // current — no separate diagnostic needed here. Bug #538.
        let inner = parse_cond_expr()?;
        skip_cond_separators();
        // c:2543-2544 — `if (tok != OUTPAR) YYERROR(ecused);`. A group
        // opened with `(` MUST close with `)`; `[[ ( a ]]` is a parse
        // error in zsh ("parse error near `]]'", status 1), not a
        // silently-accepted group. The port dropped the YYERROR and
        // accepted the unterminated group, so `[[ ( a ]]` evaluated as
        // `[[ a ]]` and exited 0.
        if tok() != OUTPAR_TOK {
            // c:2544 `YYERROR(ecused)` — the macro sets `tok = LEXERR`
            // before returning, and that is what par_dinbrack's
            // `if (tok != DOUTBRACK) YYERRORV(oecused)` (c:1818) tests.
            // Returning None alone is not enough here: the offending
            // token IS `]]`, so without the retype par_dinbrack took
            // its success arm and `[[ ( a ]]` silently exited 0.
            set_tok(LEXERR); // c:2544
            return None;
        }
        zshlex(); // c:2545 condlex()
        return Some(inner);
    }

    parse_cond_primary()
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the STRING arms of `par_cond_2` (c:2549-2624) together with the
/// `par_cond_double` / `par_cond_triple` / `par_cond_multi` arity dispatch
/// (c:2626/2659/2716), which C keeps inside `par_cond_2`.
/// Cond-expression primary: unary tests (-f, -d, ...), binary
/// tests (=, !=, <, >, ==, =~, -eq, -ne, ...), and parenthesized
/// sub-expressions. Direct port of par_cond_double / par_cond_triple
/// / par_cond_multi at parse.c:2626-2731 (chosen by arg count).
fn parse_cond_primary() -> Option<ZshCond> {
    let s1 = match tok() {
        STRING_LEX => {
            let s = tokstr().unwrap_or_default();
            zshlex();
            s
        }
        _ => {
            // c:2553-2560 — "Check first argument for [[ STRING ]]
            // re-interpretation": a non-STRING token that still carries
            // a tokstr (the lexer retypes `]]` and `!` in place, keeping
            // it) is read as its own operand, `[[ -n "$tokstr" ]]`.
            // c:2549 `dble` blocks that for a bare two-char `-X`, which
            // stays a unary operator awaiting its argument. Everything
            // else — LEXERR, and punctuation like `)` or `;` that never
            // captured a tokstr — is the YYERROR case: return None and
            // let par_cond's `tok != DOUTBRACK` arm run yyerror.
            let s1 = tokstr().unwrap_or_default();
            let s1_chars: Vec<char> = s1.chars().collect();
            // c:2549 with n_testargs == 0: `IS_DASH(*s1) && !s1[2]`.
            let dble = s1_chars.len() == 2 && IS_DASH(s1_chars[0]);
            if s1.is_empty() || tok() == LEXERR || dble {
                return None;
            }
            zshlex(); // c:2557 `do condlex(); while (COND_SEP());`
            skip_cond_separators();
            return Some(ZshCond::Unary("-n".to_string(), s1)); // c:2558
        }
    };
    skip_cond_separators();

    // !!! WARNING: RUST-ONLY ADAPTER — the AST form of C's `COND_ERROR(X,Y)`
    // macro (c:Src/parse.c:89-96):
    //   zwarn(X,Y); herrflush(); if (noerrs != 2) errflag |= ERRFLAG_ERROR;
    //   YYERROR(ecused)
    // Rust pre-formats the message, so the caller applies the `%s`
    // (nicezputs → `nicedupstring`) step itself. `YYERROR` is `tok = LEXERR`
    // plus the early `None` the cond parsers propagate.
    macro_rules! cond_error {
        ($fmt:literal, $arg:expr) => {{
            crate::ported::utils::zerr(&format!(
                $fmt,
                crate::ported::utils::nicedupstring(&$arg)
            ));
            crate::ported::utils::errflag.fetch_or(
                crate::ported::zsh_h::ERRFLAG_ERROR,
                std::sync::atomic::Ordering::Relaxed,
            );
            set_tok(LEXERR);
            return None;
        }};
    }

    let s1_chars: Vec<char> = s1.chars().collect();
    // c:2549 — `dble = (s1 && IS_DASH(*s1) && (!n_testargs || …) && !s1[2]);`
    // With n_testargs == 0 (the `[[ ]]` entry point) that is "a bare
    // two-char `-X`". A negative number (`-5`) is NOT exempt in C: it is
    // just another two-char dash word, and `[[ -5 -lt -3 ]]` still parses
    // as a triple below because the SECOND word decides (c:2599-2600).
    let dble = s1_chars.len() == 2 && IS_DASH(s1_chars[0]);

    // c:2576-2587 — `<` / `>` string comparison, checked before the
    // operand count for every s1 (a dash word included: `[[ -n < b ]]`
    // is `STRLT("-n", "b")`).
    if tok() == INANG_TOK || tok() == OUTANG_TOK {
        let op = if tok() == INANG_TOK { "<" } else { ">" };
        set_incond(incond() + 1);
        zshlex();
        set_incond(incond() - 1);
        skip_cond_separators();
        if tok() != STRING_LEX {
            // c:2580-2581 `if (tok != STRING) YYERROR(ecused);` — no message
            // of its own; par_event's yyerror reports "parse error near `]]'".
            set_tok(LEXERR);
            return None;
        }
        let s3 = tokstr().unwrap_or_default();
        zshlex(); // c:2584 `do condlex(); while (COND_SEP());`
        skip_cond_separators();
        return Some(ZshCond::Binary(s1, op.to_string(), s3)); // c:2585-2588
    }

    // c:2588-2597 — `if (tok != STRING)`: only one operand. `!dble` →
    // `par_cond_double(dupstring("-n"), s1)`; a bare `-X` →
    // `par_cond_multi(s1, newlinklist())`, a COND_MOD with no operands that
    // the evaluator rejects with "unknown condition" (c:Src/cond.c:186-193).
    // A multi-char `-prefix` is not dble, so `[[ -prefix ]]` is
    // `[[ -n -prefix ]]` → true.
    if tok() != STRING_LEX {
        if !dble {
            return Some(ZshCond::Unary("-n".to_string(), s1)); // c:2591
        }
        return Some(ZshCond::ModCond(s1, Vec::new())); // c:2593
    }

    // c:2598-2603
    //   s2 = tokstr;
    //   if (!n_testargs)
    //       dble = (s2 && IS_DASH(*s2) && !s2[2]);
    //   incond++;  -- parentheses do globbing
    //   do condlex(); while (COND_SEP());
    //   incond--;  -- parentheses do grouping
    // `dble` is RECOMPUTED from the second word: `[[ A -X B ]]` reads as the
    // two-word `par_cond_double(A, "-X")` (`[[ "" -a "x" ]]` → "parse error:
    // condition expected: "), and the bump makes the lexer keep `(` literal
    // in the RHS word (`[[ x =~ (foo) ]]`).
    let s2 = tokstr().unwrap_or_default();
    let s2_chars: Vec<char> = s2.chars().collect();
    let dble = s2_chars.len() == 2 && IS_DASH(s2_chars[0]);
    set_incond(incond() + 1);
    zshlex();
    skip_cond_separators();
    set_incond(incond() - 1);

    // c:2604-2622
    if tok() == STRING_LEX && !dble {
        let s3 = tokstr().unwrap_or_default();
        zshlex(); // c:2606 `do condlex(); while (COND_SEP());`
        skip_cond_separators();
        if tok() == STRING_LEX {
            // c:2607-2616 — a fourth word: every remaining STRING joins the
            // operand list and the whole term is `par_cond_multi(s1, l)`.
            let mut l: Vec<String> = vec![s2, s3];
            while tok() == STRING_LEX {
                l.push(tokstr().unwrap_or_default());
                zshlex();
                skip_cond_separators();
            }
            // c:2716-2719 par_cond_multi —
            //   if (!IS_DASH(a[0]) || !a[1])
            //       COND_ERROR("condition expected: %s", a);
            if !(s1_chars.len() >= 2 && IS_DASH(s1_chars[0])) {
                cond_error!("condition expected: {}", s1);
            }
            return Some(ZshCond::ModCond(s1, l)); // c:2722-2726 COND_MOD
        }

        // c:2618 `par_cond_triple(s1, s2, s3)` (c:2659-2712). The operator
        // checks run in C's order: `=`, `<`/`>`, `==`, `!=`, `=~`, a dash
        // operator, then a dash FIRST word.
        let bc = &s2_chars;
        let is_eq = |ch: char| ch == '=' || ch == Equals;
        let is_bang = |ch: char| ch == '!' || ch == Bang;
        // c:2663 `(b[0] == Equals || b[0] == '=') && !b[1]` → COND_STREQ
        // c:2668 `(b[0] == '>' || Outang || '<' || Inang) && !b[1]`
        // c:2674 `==` → COND_STRDEQ, c:2680 `!=` → COND_STRNEQ
        let string_op = (bc.len() == 1
            && (is_eq(bc[0]) || matches!(bc[0], '<' | '>') || bc[0] == Inang || bc[0] == Outang))
            || (bc.len() == 2 && is_eq(bc[0]) && is_eq(bc[1]))
            || (bc.len() == 2 && is_bang(bc[0]) && is_eq(bc[1]));
        // c:2685-2686 `(b[0] == Equals || '=') && (b[1] == '~' || Tilde) &&
        // !b[2]` → COND_REGEX. The lexer hands the TOKEN forms (`=` at word
        // start → Equals, `~` → Tilde) inside cond bodies.
        if bc.len() == 2 && is_eq(bc[0]) && (bc[1] == '~' || bc[1] == Tilde) {
            return Some(ZshCond::Regex(s1, s3));
        }
        // c:2692-2702 — `IS_DASH(b[0])`: a numeric/file operator
        // (`get_cond_num`) or an infix module condition (COND_MODI). Both
        // stay a Binary node; the evaluator reports an unknown `-X`.
        if string_op || bc.first().is_some_and(|&ch| IS_DASH(ch)) {
            return Some(ZshCond::Binary(s1, s2, s3));
        }
        // c:2703-2707 — `IS_DASH(a[0]) && a[1]`: `WCB_COND(COND_MOD, 2)`
        // named by the first word, so `[[ -n a b ]]` evaluates to "unknown
        // condition: -n" (status 2) instead of failing to parse.
        if s1_chars.len() >= 2 && IS_DASH(s1_chars[0]) {
            return Some(ZshCond::ModCond(s1, vec![s2, s3]));
        }
        // c:2709 `COND_ERROR("condition expected: %s", b)`.
        cond_error!("condition expected: {}", s2);
    }

    // c:2620 `par_cond_double(s1, s2)` (c:2626-2640) —
    //   if (!IS_DASH(a[0]) || !a[1])
    //       COND_ERROR("parse error: condition expected: %s", a);
    //   else if (!a[2] && strspn(a+1, "abcdefgknoprstuvwxzhLONGS") == 1)
    //       WCB_COND(a[1], 0)          -- the builtin unary test
    //   else
    //       WCB_COND(COND_MOD, 1)      -- a one-operand module condition
    if !(s1_chars.len() >= 2 && IS_DASH(s1_chars[0])) {
        cond_error!("parse error: condition expected: {}", s1);
    }
    if s1_chars.len() == 2 && "abcdefgknoprstuvwxzhLONGS".contains(s1_chars[1]) {
        return Some(ZshCond::Unary(s1, s2)); // c:2631-2632
    }
    Some(ZshCond::ModCond(s1, vec![s2])) // c:2634-2637
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for C's open-coded `while (COND_SEP()) condlex();` separator skip,
/// repeated at c:2413, c:2418, c:2437 and c:2442.
fn skip_cond_separators() {
    // c:2405 `COND_SEP()` — a `;` is NOT a cond separator, so it ends
    // the condition and becomes the token the parse error names
    // (`[[ ]];` → "parse error near `;'"). Testing `tokstr` for a `;`
    // never saw one: SEPER carries no tokstr, so the old `unwrap_or`
    // swallowed every `;` and the error pointed one token too far.
    while COND_SEP() {
        zshlex();
    }
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the `case DINPAR:` arm of `par_cmd` (c:1031-1035) in AST form,
/// building a `ZshCommand::Arith`.
/// Parse (( ... )) arithmetic command
/// Parse `(( EXPR ))` arithmetic command. C source: parse.c:1810-1834
/// `par_dinbrack` (despite the name; the function actually handles
/// DINPAR `(( ))` blocks too).
fn parse_arith() -> Option<ZshCommand> {
    let expr = tokstr().unwrap_or_default();
    zshlex();
    Some(ZshCommand::Arith(expr))
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for C's open-coded `while (tok == SEPER) zshlex();` skips at the head of
/// `par_list` (c:774-775) and friends.
/// Skip separator tokens
fn skip_separators() {
    while tok() == SEPER || tok() == NEWLIN {
        zshlex();
    }
}

// `fdheaderlen` / `fdmagic` / `fdflags` / etc. macros from
// `Src/parse.c:3125-3152`. C uses raw pointer arithmetic on a
// `Wordcode` (= `u32 *`); the Rust port takes a slice and indexes.

/// Port of `fdheaderlen()` from `Src/parse.c:3125` — C decl `#define fdheaderlen(f) (((Wordcode) (f))[FD_PRELEN])`. C macro; the Rust port indexes a `&[u32]` where C does `Wordcode` pointer arithmetic.
/// ) — header
/// length in u32 words (read from prelude word `FD_PRELEN`).
#[inline]
pub fn fdheaderlen(f: &[u32]) -> u32 {
    f[FD_PRELEN]
}

/// Port of `fdmagic()` from `Src/parse.c:3127` — C decl `#define fdmagic(f) (((Wordcode) (f))[0])`. C macro.
/// ) — first prelude
/// word, either `FD_MAGIC` or `FD_OMAGIC`.
#[inline]
pub fn fdmagic(f: &[u32]) -> u32 {
    f[0]
}

/// Port of `fdflags()` from `Src/parse.c:3131` — C decl `#define fdflags(f) fdbyte(f, 0)`. C macro (via `fdbyte`, c:3129).
/// ) — low byte of
/// the packed `pre[1]` word.
#[inline]
pub fn fdflags(f: &[u32]) -> u32 {
    // `pre[1]` is a u32 viewed as 4 bytes; flags = byte 0.
    f[1] & 0xff
}

/// Port of `fdsetflags()` from `Src/parse.c:3132` — C decl `#define fdsetflags(f,v) fdsetbyte(f, 0, v)`. C macro (via `fdsetbyte`, c:3128).
/// ) — write
/// the low byte of `pre[1]`.
#[inline]
pub fn fdsetflags(f: &mut [u32], v: u8) {
    f[1] = (f[1] & !0xff) | (v as u32);
}

/// Port of `fdother()` from `Src/parse.c:3133` — C decl `#define fdother(f) (fdbyte(f, 1) + (fdbyte(f, 2) << 8) + (fdbyte(f, 3) << 16))`. C macro.
/// ) — high 24 bits
/// of `pre[1]`, holds the byte-offset to the opposite-byte-order
/// dump copy.
#[inline]
pub fn fdother(f: &[u32]) -> u32 {
    (f[1] >> 8) & 0x00ff_ffff
}

/// Port of `fdsetother()` from `Src/parse.c:3134` — C decl `#define fdsetother(f, o) do { fdsetbyte(f, 1, ((o) & 0xff)); fdsetbyte(f, 2, (((o) >> 8) & 0xff)); fdsetbyte(f, 3, (((o) >> 16) & 0xff)); } while (0)`. C macro.
/// ).
#[inline]
pub fn fdsetother(f: &mut [u32], o: u32) {
    f[1] = (f[1] & 0xff) | ((o & 0x00ff_ffff) << 8);
}

/// Port of `fdversion()` from `Src/parse.c:3140` — C decl `#define fdversion(f) ((char *) ((f) + 2))`. C macro; the Rust port copies the NUL-terminated string out instead of returning a pointer into the dump.
/// ) — read the
/// `ZSH_VERSION` C-string from `pre[2..]`.
pub fn fdversion(f: &[u32]) -> String {
    let bytes: Vec<u8> = f[2..]
        .iter()
        .take(10)
        .flat_map(|w| w.to_le_bytes().into_iter())
        .collect();
    let end = bytes.iter().position(|&b| b == 0).unwrap_or(bytes.len());
    String::from_utf8_lossy(&bytes[..end]).into_owned()
}

/// Port of `firstfdhead` from `Src/parse.c:3142` — C decl `#define firstfdhead(f) ((FDHead) (((Wordcode) (f)) + FD_PRELEN))`. Rust fn `firstfdhead_offset` returns the u32-word OFFSET of the first `fdhead` rather than a `FDHead` pointer.
/// ) — pointer
/// to the first `struct fdhead` past the prelude.
#[inline]
pub fn firstfdhead_offset() -> usize {
    FD_PRELEN
}

/// Port of `nextfdhead` from `Src/parse.c:3143` — C decl `#define nextfdhead(f) ((FDHead) (((Wordcode) (f)) + (f)->hlen))`. Rust fn `nextfdhead_offset` returns the u32-word OFFSET of the next `fdhead` rather than a `FDHead` pointer.
/// ) — advance to
/// the next header by reading the current `hlen` slot.
#[inline]
pub fn nextfdhead_offset(f: &[u32], cur: usize) -> usize {
    cur + (f[cur + 4] as usize) // .hlen is field 4 of fdhead
}

/// Port of `fdhflags()` from `Src/parse.c:3145` — C decl `#define fdhflags(f) (((FDHead) (f))->flags)`. C macro.
/// ) — low 2 bits
/// of the header's `flags` field (the kshload/zshload marker).
#[inline]
pub fn fdhflags(h: &fdhead) -> u32 {
    h.flags & 0x3
}

/// Port of `fdhtail()` from `Src/parse.c:3146` — C decl `#define fdhtail(f) (((FDHead) (f))->flags >> 2)`. C macro.
/// ) — high 30 bits
/// of `flags`, byte offset from the name start to its basename.
#[inline]
pub fn fdhtail(h: &fdhead) -> u32 {
    h.flags >> 2
}

/// Port of `fdhbldflags()` from `Src/parse.c:3147` — C decl `#define fdhbldflags(f,t) ((f) | ((t) << 2))`. C macro.
/// ) — pack
/// `(flags, tail)` into one u32 (low 2 bits = flags, high 30 = tail).
#[inline]
pub fn fdhbldflags(flags: u32, tail: u32) -> u32 {
    flags | (tail << 2)
}

/// Port of `fdname()` from `Src/parse.c:3152` — C decl `#define fdname(f) ((char *) (((FDHead) (f)) + 1))`. C macro; the Rust port copies the NUL-terminated name out of the dump buffer.
/// ) — name string
/// follows the fdhead record immediately. Reads bytes from the
/// dump buffer until NUL.
pub fn fdname(buf: &[u32], header_offset: usize) -> String {
    let name_word_off = header_offset + FDHEAD_WORDS;
    let bytes: Vec<u8> = buf[name_word_off..]
        .iter()
        .flat_map(|w| w.to_le_bytes().into_iter())
        .take_while(|&b| b != 0)
        .collect();
    String::from_utf8_lossy(&bytes).into_owned()
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for decoding one `struct fdhead` record (c:3116-3123) out of a `&[u32]`
/// dump buffer. C needs no decoder: it casts the buffer to `FDHead` and reads
/// the struct in place.
/// Decode a `fdhead` record at the given u32-word offset in the
/// dump buffer. Used by the header-walk loops in `bin_zcompile -t`.
pub fn read_fdhead(buf: &[u32], offset: usize) -> Option<fdhead> {
    if offset + FDHEAD_WORDS > buf.len() {
        return None;
    }
    Some(fdhead {
        start: buf[offset],
        len: buf[offset + 1],
        npats: buf[offset + 2],
        strs: buf[offset + 3],
        hlen: buf[offset + 4],
        flags: buf[offset + 5],
    })
}

/// Port of `freedump()` from `Src/parse.c:3976` — C signature `freedump(FuncDump f)`. C
/// `munmap`s, `zclose`s the fd, and frees the struct. The Rust
/// port relies on Drop for the `funcdump` (no mmap held in this
/// port — `addr`/`map` are byte-offset placeholders), so the
/// equivalent is removing the entry from the dumps list. Called
/// by `decrdumpcount` when the refcount hits zero (c:3988) and
/// by `closedumps` when shutting down (c:4008).
fn freedump_locked(g: &mut std::sync::MutexGuard<'_, Vec<funcdump>>, filename: &str) {
    // c:3976
    g.retain(|d| d.filename.as_deref() != Some(filename));
}

// =====================================================================
// Remaining `Src/parse.c` ports (this section finishes the file).
//
// Several of these emit into the C-wordcode buffer (`ECBUF`/etc.) and
// are kept for completeness — the live zshrs runtime uses the
// `ZshProgram` AST path instead, but `bin_zcompile` (`-c`/`-a` modes)
// and any future `.zwc`-emit pipeline both call into these.
// =====================================================================

/// Port of `ecstr()` from `Src/parse.c:473` — C decl `#define ecstr(S) ecadd(ecstrcode(S))`. C macro.
/// `ecstr(s)` helper — `ecadd(ecstrcode(s))`. Mirrors the C macro at
/// `Src/parse.c:473` used everywhere by the par_* emitters.
#[inline]
pub fn ecstr(s: &str) {
    let code = ecstrcode(s);
    ecadd(code);
}

/// Port of the `condlex` function-pointer global from `Src/parse.c:2399` —
/// C decl `void (*condlex) (void) = zshlex;`. C repoints it between `zshlex`
/// and `testlex` (builtin.c:7200); `CONDLEX_TESTLEX` is that pointer, true
/// while it addresses `testlex`. `bin_test` sets it around `parse_cond`
/// (builtin.c:7278, 7280) and `par_cond_2` compares it (`condlex == testlex`,
/// c:2480) exactly as C does.
thread_local! {
    pub static CONDLEX_TESTLEX: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}

/// Port of calling through `condlex` from `Src/parse.c:2399`: dispatches to
/// `testlex` while `CONDLEX_TESTLEX` is set, otherwise to `zshlex`.
#[inline]
pub fn condlex() {
    if CONDLEX_TESTLEX.get() {
        crate::ported::builtin::testlex();
    } else {
        zshlex();
    }
}

/// !!! WARNING: RUST-ONLY HELPER !!!
///
/// No function of this name exists in `Src/parse.c`. This helper stands in
/// for the recursive tree walk that C writes as a self-recursive call inside
/// `copy_ecstr` itself (c:537-545).
fn copy_ecstr_walk(node: &Option<Box<EccstrNode>>, p: &mut [u8]) {
    let mut cur = node.as_ref();
    while let Some(n) = cur {
        // c:540 — `memcpy(p + s->aoffs, s->str, strlen(s->str) + 1);`
        let off = n.aoffs as usize;
        let need = off + n.str.len() + 1;
        if need <= p.len() {
            p[off..off + n.str.len()].copy_from_slice(&n.str);
            p[off + n.str.len()] = 0;
        }
        // c:541 — `copy_ecstr(s->left, p);`
        copy_ecstr_walk(&n.left, p);
        // c:542 — `s = s->right;`
        cur = n.right.as_ref();
    }
}

/// Port of `par_cond()` from `Src/parse.c:2409` — C signature `par_cond(void)`. Top-level cond
/// OR-chain — drives `par_cond_1` and stitches `||`-separated terms
/// with `WCB_COND(COND_OR, …)`. This is the missing top of the
/// wordcode cond chain: `par_cond_wordcode` (the par_dinbrack port)
/// must call into HERE so that `[[ a || b ]]` and friends land
/// real WC_COND opcodes in `ecbuf`. Without this, the wordcode
/// emitter for `[[ ... ]]` produced zero words and parity dropped
/// 148 words on `/etc/zshrc` alone.
pub fn par_cond_top() -> i32 {
    // c:2411 — `int p = ecused, r;`
    let p = ECUSED.with(|c| c.get()) as usize;
    let r = par_cond_1();
    while COND_SEP() {
        condlex();
    }
    if tok() == DBAR {
        // c:2417 — `condlex(); while (COND_SEP()) condlex();`
        condlex();
        while COND_SEP() {
            condlex();
        }
        // c:2420-2422 — `ecispace(p, 1); par_cond(); ecbuf[p] =
        // WCB_COND(COND_OR, ecused-1-p);`
        ecispace(p, 1);
        par_cond_top();
        let ecused = ECUSED.with(|c| c.get()) as usize;
        ECBUF.with(|c| {
            c.borrow_mut()[p] = WCB_COND(COND_OR as u32, (ecused - 1 - p) as u32);
        });
        return 1;
    }
    r
}

/// Port of `check_cond()` from `Src/parse.c:2459` — C decl `static int check_cond(const char *input, const char *cond)`.
/// True iff `input` is the two-char `-X`
/// form whose `X` matches `cond` — used by par_cond_2 to detect
/// `-a` / `-o` n-ary chain operators and by build_dump for `-k` /
/// `-z`. C: `return !IS_DASH(input[0]) ? 0 : !strcmp(input+1, cond);`.
pub fn check_cond(input: &str, cond: &str) -> bool {
    let mut chars = input.chars();
    match chars.next() {
        Some(c) if IS_DASH(c) => chars.as_str() == cond,
        _ => false,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::utils::{errflag, ERRFLAG_ERROR};
    use std::fs;
    use std::path::Path;
    use std::sync::atomic::Ordering;
    use std::sync::mpsc;
    use std::thread;
    use std::time::Duration;

    /// `try_source_file` MUST refuse a stale `.zwc` cache when the
    /// uncompiled source has been modified more recently. The C body
    /// at c:3819 reads `stc.st_mtime >= stn.st_mtime` — explicitly
    /// `>=`, meaning only an equal-or-newer zwc is acceptable.
    ///
    /// A regression that ignored the mtime check (or used the wrong
    /// direction) would silently keep loading the OLD compiled body
    /// after the user edited the source file — every `source foo.zsh`
    /// would replay yesterday's code, the worst-class shell bug.
    ///
    /// Pin: create source + .zwc, then touch source to make it
    /// newer. try_source_file must return None.
    #[test]
    fn try_source_file_skips_stale_zwc() {
        let _g = crate::test_util::global_state_lock();
        let dir = tempfile::tempdir().expect("tempdir");
        let src = dir.path().join("script.zsh");
        let zwc = dir.path().join("script.zsh.zwc");
        // Create zwc FIRST (older), then source (newer).
        fs::write(&zwc, b"placeholder zwc").unwrap();
        thread::sleep(Duration::from_millis(20));
        fs::write(&src, b"echo hi").unwrap();

        let result = try_source_file(src.to_str().unwrap());
        assert!(
            result.is_none(),
            "c:3819 — stale .zwc (older than source) MUST be rejected; \
             got {:?}",
            result
        );
    }

    /// `try_source_file` returns None when no `.zwc` exists for the
    /// requested file (c:3819 `if let Ok(meta_c) = &stc` gate fails).
    /// This is the common case — most user scripts don't ship with
    /// a pre-compiled `.zwc`. The fn returning None lets the caller
    /// fall through to the source-read path. A regression that
    /// returned `Some(file)` on missing `.zwc` would route every
    /// `source foo.zsh` through `check_dump_file` against a
    /// non-existent file and crash.
    #[test]
    fn try_source_file_returns_none_when_no_zwc() {
        let _g = crate::test_util::global_state_lock();
        let dir = tempfile::tempdir().expect("tempdir");
        let src = dir.path().join("plain.zsh");
        fs::write(&src, b"echo hi").unwrap();
        // No .zwc sibling.

        let result = try_source_file(src.to_str().unwrap());
        assert!(
            result.is_none(),
            "c:3819 gate fails when stat(wc) returns Err → None"
        );
    }

    /// Test helper. Mirrors zsh's `errflag` save/clear/check pattern
    /// around a parse — see `Src/init.c:loop` which clears errflag
    /// before parse_event() and tests it after. Returns `Err` if the
    /// parse set `ERRFLAG_ERROR`; otherwise `Ok(program)`.
    fn parse(input: &str) -> Result<ZshProgram, String> {
        let saved = errflag.load(Ordering::Relaxed);
        errflag.fetch_and(!ERRFLAG_ERROR, Ordering::Relaxed);
        parse_init(input);
        let prog = crate::ported::parse::parse();
        let had_err = (errflag.load(Ordering::Relaxed) & ERRFLAG_ERROR) != 0;
        // Restore prior error bits; don't carry our new error into the
        // outer test runner.
        errflag.store(saved, Ordering::Relaxed);
        if had_err {
            Err("parse error".to_string())
        } else {
            Ok(prog)
        }
    }

    #[test]
    fn test_simple_command() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("echo hello world").unwrap();
        assert_eq!(prog.lists.len(), 1);
        match &prog.lists[0].sublist.pipe.cmd {
            ZshCommand::Simple(s) => {
                assert_eq!(s.words, vec!["echo", "hello", "world"]);
            }
            _ => panic!("expected simple command"),
        }
    }

    #[test]
    fn test_pipeline() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("ls | grep foo | wc -l").unwrap();
        assert_eq!(prog.lists.len(), 1);

        let pipe = &prog.lists[0].sublist.pipe;
        assert!(pipe.next.is_some());

        let pipe2 = pipe.next.as_ref().unwrap();
        assert!(pipe2.next.is_some());
    }

    #[test]
    fn test_and_or() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("cmd1 && cmd2 || cmd3").unwrap();
        let sublist = &prog.lists[0].sublist;

        assert!(sublist.next.is_some());
        let (op, _) = sublist.next.as_ref().unwrap();
        assert_eq!(*op, SublistOp::And);
    }

    #[test]
    fn test_if_then() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("if test -f foo; then echo yes; fi").unwrap();
        match &prog.lists[0].sublist.pipe.cmd {
            ZshCommand::If(_) => {}
            _ => panic!("expected if command"),
        }
    }

    #[test]
    fn test_for_loop() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("for i in a b c; do echo $i; done").unwrap();
        match &prog.lists[0].sublist.pipe.cmd {
            ZshCommand::For(f) => {
                assert_eq!(f.var, "i");
                match &f.list {
                    ForList::Words(w) => assert_eq!(w, &vec!["a", "b", "c"]),
                    _ => panic!("expected word list"),
                }
            }
            _ => panic!("expected for command"),
        }
    }

    #[test]
    fn test_case() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("case $x in a) echo a;; b) echo b;; esac").unwrap();
        match &prog.lists[0].sublist.pipe.cmd {
            ZshCommand::Case(c) => {
                assert_eq!(c.arms.len(), 2);
            }
            _ => panic!("expected case command"),
        }
    }

    #[test]
    fn test_function() {
        let _g = crate::test_util::global_state_lock();
        // First test just parsing "function foo" to see what happens
        let prog = parse("function foo { }").unwrap();
        match &prog.lists[0].sublist.pipe.cmd {
            ZshCommand::FuncDef(f) => {
                assert_eq!(f.names, vec!["foo"]);
            }
            _ => panic!(
                "expected function, got {:?}",
                prog.lists[0].sublist.pipe.cmd
            ),
        }
    }

    #[test]
    fn test_redirection() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("echo hello > file.txt").unwrap();
        match &prog.lists[0].sublist.pipe.cmd {
            ZshCommand::Simple(s) => {
                assert_eq!(s.redirs.len(), 1);
                assert_eq!(s.redirs[0].rtype, REDIR_WRITE);
            }
            _ => panic!("expected simple command"),
        }
    }

    /// Regression: `{var}>file` named-fd redirects accept any IIDENT name,
    /// including all-digit positional-parameter names like `{1}` (used by
    /// p10k's `_p9k_restore_prompt`: `exec {1}>&-`). The prior check required
    /// the first char to be alphabetic/`_`, which rejected `{1}`/`{2}`/`{12}`
    /// and made zshrs treat `{1}` as a command word — `command not found: {1}`.
    /// zsh's rule is `itype_end(tokstr+1, IIDENT, 0) >= ptr` (per-char IIDENT,
    /// no first-char restriction).
    #[test]
    fn test_fd_var_redir_digit_name() {
        let _g = crate::test_util::global_state_lock();
        for (src, want) in [
            ("echo hi {1}>file", "1"),
            ("echo hi {2}>file", "2"),
            ("echo hi {12}>file", "12"),
            ("echo hi {myfd}>file", "myfd"),
            ("echo hi {fd1}>file", "fd1"),
        ] {
            let prog = parse(src).unwrap_or_else(|_| panic!("failed to parse {src:?}"));
            match &prog.lists[0].sublist.pipe.cmd {
                ZshCommand::Simple(s) => {
                    assert_eq!(s.redirs.len(), 1, "{src:?}");
                    assert_eq!(
                        s.redirs[0].varid.as_deref(),
                        Some(want),
                        "{src:?} should carry fd-var {want:?}"
                    );
                }
                _ => panic!("expected simple command for {src:?}"),
            }
        }
    }

    #[test]
    fn test_assignment() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("FOO=bar echo $FOO").unwrap();
        match &prog.lists[0].sublist.pipe.cmd {
            ZshCommand::Simple(s) => {
                assert_eq!(s.assigns.len(), 1);
                assert_eq!(s.assigns[0].name, "FOO");
            }
            _ => panic!("expected simple command"),
        }
    }

    #[test]
    fn test_parse_completion_function() {
        let _g = crate::test_util::global_state_lock();
        let input = r#"_2to3_fixes() {
  local -a fixes
  fixes=( ${${(M)${(f)"$(2to3 --list-fixes 2>/dev/null)"}:#*}//[[:space:]]/} )
  (( ${#fixes} )) && _describe -t fixes 'fix' fixes
}"#;
        let result = parse(input);
        assert!(
            result.is_ok(),
            "Failed to parse completion function: {:?}",
            result.err()
        );
        let prog = result.unwrap();
        assert!(
            !prog.lists.is_empty(),
            "Expected at least one list in program"
        );
    }

    #[test]
    fn test_parse_array_with_complex_elements() {
        let _g = crate::test_util::global_state_lock();
        let input = r#"arguments=(
  '(- * :)'{-h,--help}'[show this help message and exit]'
  {-d,--doctests_only}'[fix up doctests only]'
  '*:filename:_files'
)"#;
        let result = parse(input);
        assert!(
            result.is_ok(),
            "Failed to parse array assignment: {:?}",
            result.err()
        );
    }

    #[test]
    fn test_parse_full_completion_file() {
        let _g = crate::test_util::global_state_lock();
        let input = r##"#compdef 2to3

# zsh completions for '2to3'

_2to3_fixes() {
  local -a fixes
  fixes=( ${${(M)${(f)"$(2to3 --list-fixes 2>/dev/null)"}:#*}//[[:space:]]/} )
  (( ${#fixes} )) && _describe -t fixes 'fix' fixes
}

local -a arguments

arguments=(
  '(- * :)'{-h,--help}'[show this help message and exit]'
  {-d,--doctests_only}'[fix up doctests only]'
  {-f,--fix}'[each FIX specifies a transformation; default: all]:fix name:_2to3_fixes'
  {-j,--processes}'[run 2to3 concurrently]:number: '
  {-x,--nofix}'[prevent a transformation from being run]:fix name:_2to3_fixes'
  {-l,--list-fixes}'[list available transformations]'
  {-p,--print-function}'[modify the grammar so that print() is a function]'
  {-v,--verbose}'[more verbose logging]'
  '--no-diffs[do not show diffs of the refactoring]'
  {-w,--write}'[write back modified files]'
  {-n,--nobackups}'[do not write backups for modified files]'
  {-o,--output-dir}'[put output files in this directory instead of overwriting]:directory:_directories'
  {-W,--write-unchanged-files}'[also write files even if no changes were required]'
  '--add-suffix[append this string to all output filenames]:suffix: '
  '*:filename:_files'
)

_arguments -s -S $arguments
"##;
        let result = parse(input);
        assert!(
            result.is_ok(),
            "Failed to parse full completion file: {:?}",
            result.err()
        );
        let prog = result.unwrap();
        // Should have parsed successfully with at least one statement
        assert!(!prog.lists.is_empty(), "Expected at least one list");
    }

    #[test]
    fn test_parse_logs_sh() {
        let _g = crate::test_util::global_state_lock();
        let input = r#"#!/usr/bin/env bash
shopt -s globstar

if [[ $(uname) == Darwin ]]; then
    tail -f /var/log/**/*.log /var/log/**/*.out | lolcat
else
    if [[ $ZPWR_DISTRO_NAME == raspbian ]]; then
        tail -f /var/log/**/*.log | lolcat
    else
        printf "Unsupported...\n" >&2
    fi
fi
"#;
        let result = parse(input);
        assert!(
            result.is_ok(),
            "Failed to parse logs.sh: {:?}",
            result.err()
        );
    }

    #[test]
    fn test_parse_case_with_glob() {
        let _g = crate::test_util::global_state_lock();
        let input = r#"case "$ZPWR_OS_TYPE" in
    darwin*)  open_cmd='open'
      ;;
    cygwin*)  open_cmd='cygstart'
      ;;
    linux*)
        open_cmd='xdg-open'
      ;;
esac"#;
        let result = parse(input);
        assert!(
            result.is_ok(),
            "Failed to parse case with glob: {:?}",
            result.err()
        );
    }

    #[test]
    fn test_parse_case_with_nested_if() {
        let _g = crate::test_util::global_state_lock();
        // Test case with nested if and glob patterns
        let input = r##"function zpwrGetOpenCommand(){
    local open_cmd
    case "$ZPWR_OS_TYPE" in
        darwin*)  open_cmd='open' ;;
        cygwin*)  open_cmd='cygstart' ;;
        linux*)
            if [[ "$_zpwr_uname_r" != *icrosoft* ]];then
                open_cmd='nohup xdg-open'
            fi
            ;;
    esac
}"##;
        let result = parse(input);
        assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
    }

    #[test]
    fn test_parse_zpwr_scripts() {
        let _g = crate::test_util::global_state_lock();
        let scripts_dir = Path::new("/Users/wizard/.zpwr/scripts");
        if !scripts_dir.exists() {
            eprintln!("Skipping test: scripts directory not found");
            return;
        }

        let mut total = 0;
        let mut passed = 0;
        let mut failed_files = Vec::new();
        let mut timeout_files = Vec::new();

        for ext in &["sh", "zsh"] {
            let pattern = scripts_dir.join(format!("*.{}", ext));
            if let Ok(entries) = glob::glob(pattern.to_str().unwrap()) {
                for entry in entries.flatten() {
                    total += 1;
                    let file_path = entry.display().to_string();
                    let content = match fs::read_to_string(&entry) {
                        Ok(c) => c,
                        Err(e) => {
                            failed_files.push((file_path, format!("read error: {}", e)));
                            continue;
                        }
                    };

                    // Parse with timeout
                    let content_clone = content.clone();
                    let (tx, rx) = mpsc::channel();
                    let handle = thread::spawn(move || {
                        let result = parse(&content_clone);
                        let _ = tx.send(result);
                    });

                    match rx.recv_timeout(Duration::from_secs(2)) {
                        Ok(Ok(_)) => passed += 1,
                        Ok(Err(err)) => {
                            failed_files.push((file_path, err));
                        }
                        Err(_) => {
                            timeout_files.push(file_path);
                            // Thread will be abandoned
                        }
                    }
                }
            }
        }

        eprintln!("\n=== ZPWR Scripts Parse Results ===");
        eprintln!("Passed: {}/{}", passed, total);

        if !timeout_files.is_empty() {
            eprintln!("\nTimeout files (>2s):");
            for file in &timeout_files {
                eprintln!("  {}", file);
            }
        }

        if !failed_files.is_empty() {
            eprintln!("\nFailed files:");
            for (file, err) in &failed_files {
                eprintln!("  {} - {}", file, err);
            }
        }

        // Allow some failures initially, but track progress
        let pass_rate = if total > 0 {
            (passed as f64 / total as f64) * 100.0
        } else {
            0.0
        };
        eprintln!("Pass rate: {:.1}%", pass_rate);

        // Require at least 50% pass rate for now
        assert!(pass_rate >= 50.0, "Pass rate too low: {:.1}%", pass_rate);
    }

    /// c:2643 — `get_cond_num` returns 0..=8 for the canonical binary
    /// test operators in order `nt ot ef eq ne lt gt le ge`. The
    /// index IS the wordcode opcode dispatch key; flipping any entry
    /// would silently mis-dispatch `[[ a -eq b ]]` to a different op.
    #[test]
    fn get_cond_num_canonical_order_matches_dispatch_table() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(get_cond_num("nt"), 0);
        assert_eq!(get_cond_num("ot"), 1);
        assert_eq!(get_cond_num("ef"), 2);
        assert_eq!(get_cond_num("eq"), 3);
        assert_eq!(get_cond_num("ne"), 4);
        assert_eq!(get_cond_num("lt"), 5);
        assert_eq!(get_cond_num("gt"), 6);
        assert_eq!(get_cond_num("le"), 7);
        assert_eq!(get_cond_num("ge"), 8);
    }

    /// c:2643 — unknown operator returns -1 (sentinel for "not in the
    /// binary set"). Regression returning 0 silently would alias
    /// every unknown op to `-nt`, dispatching to the wrong handler.
    #[test]
    fn get_cond_num_unknown_operator_returns_minus_one() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(get_cond_num("xx"), -1);
        assert_eq!(get_cond_num(""), -1);
        assert_eq!(get_cond_num("eqnt"), -1, "exact-match required");
        assert_eq!(
            get_cond_num("NT"),
            -1,
            "case-sensitive — uppercase rejected"
        );
    }

    /// c:2628 — `par_cond_double` requires arg `a` to start with `-`
    /// AND have at least one more char. Empty string OR single `-`
    /// must error (return 1 via zerr). Regression accepting empty
    /// would dispatch `[[ "" string ]]` as a unary test.
    #[test]
    fn par_cond_double_rejects_short_or_non_dash_first_arg() {
        let _g = crate::test_util::global_state_lock();
        // empty
        let _ = par_cond_double("", "b");
        // not-dash
        let _ = par_cond_double("foo", "b");
        // bare dash
        let _ = par_cond_double("-", "b");
        // All three must NOT crash + return 1 (error path).
    }

    /// c:89-96 `COND_ERROR` — `YYERROR(ecused)` is `tok = LEXERR; return 0`,
    /// so every cond-term error path returns 0 and leaves the lexer in
    /// LEXERR, with `ERRFLAG_ERROR` raised unless `noerrs == 2`.
    #[test]
    fn par_cond_errors_return_zero_and_set_lexerr() {
        let _g = crate::test_util::global_state_lock();
        let reset = || {
            crate::ported::utils::errflag.store(0, Ordering::SeqCst);
            set_tok(crate::ported::zsh_h::NULLTOK);
        };
        let errored = || {
            tok() == LEXERR
                && crate::ported::utils::errflag.load(Ordering::SeqCst) & ERRFLAG_ERROR != 0
        };

        reset();
        assert_eq!(par_cond_double("foo", "b"), 0); // c:2629
        assert!(errored());

        reset();
        assert_eq!(par_cond_triple("a", "foo", "c"), 0); // c:2709
        assert!(errored());

        reset();
        assert_eq!(par_cond_multi("a", &["b".to_string()]), 0); // c:2719
        assert!(errored());

        // c:92 — `if (noerrs != 2) errflag |= ERRFLAG_ERROR;`
        reset();
        *crate::ported::utils::noerrs_lock().lock().unwrap() = 2;
        let r = par_cond_triple("a", "foo", "c");
        *crate::ported::utils::noerrs_lock().lock().unwrap() = 0;
        assert_eq!(r, 0);
        assert_eq!(tok(), LEXERR);
        assert_eq!(crate::ported::utils::errflag.load(Ordering::SeqCst), 0);
        reset();
    }

    /// c:2647 CONDSTRS table — exhaustive iteration: every entry's
    /// index round-trips through get_cond_num. A regression that
    /// drops an entry would let `[[ a -ef b ]]` silently mis-dispatch.
    #[test]
    fn get_cond_num_round_trips_for_every_table_entry() {
        let _g = crate::test_util::global_state_lock();
        for (i, op) in ["nt", "ot", "ef", "eq", "ne", "lt", "gt", "le", "ge"]
            .iter()
            .enumerate()
        {
            assert_eq!(get_cond_num(op) as usize, i, "{op} must map to index {i}");
        }
    }

    /// c:2643 — `get_cond_num` is byte-exact: a partial-prefix string
    /// must NOT match. `e` (one char) is not `eq`. Catches a
    /// regression using `starts_with` instead of equality.
    #[test]
    fn get_cond_num_partial_prefix_does_not_match() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(get_cond_num("e"), -1);
        assert_eq!(get_cond_num("eq2"), -1);
        assert_eq!(get_cond_num("n"), -1);
    }

    /// c:2628 — `par_cond_double` checks `IS_DASH(ac[0])` so any
    /// non-dash first char fails. The lexed Dash sentinel `\u{e19b}`
    /// MUST be accepted alongside ASCII `-` (the lexer emits it
    /// inside `[[ ... ]]`). Regression dropping the sentinel form
    /// would break every cond expression after lexing.
    #[test]
    fn par_cond_double_accepts_lexed_dash_sentinel() {
        let _g = crate::test_util::global_state_lock();
        // First char being the Dash sentinel + valid unary letter
        // must NOT trigger the "condition expected" error path.
        // We can't easily probe the wordcode emission here, but
        // the function MUST return without panic for both forms.
        let _ = par_cond_double("-z", "foo");
        let _ = par_cond_double("\u{e19b}z", "foo");
    }

    /// c:2643 — case sensitivity: uppercase `EQ` MUST NOT match `eq`.
    /// zsh's `[[ a -EQ b ]]` is documented as a parse error (only
    /// lowercase variants are recognised). Regression doing
    /// case-insensitive lookup would silently accept it.
    #[test]
    fn get_cond_num_is_case_sensitive() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(get_cond_num("EQ"), -1);
        assert_eq!(get_cond_num("Eq"), -1);
        assert_eq!(get_cond_num("eQ"), -1);
        // Lowercase still works.
        assert_eq!(get_cond_num("eq"), 3);
    }

    /// `Src/parse.c:2862-2868` — `ecgetstr` inline-3-byte case packs
    /// up to 3 chars into bits 3-26 of the wordcode word, then C emits
    /// `buf[3] = '\0'; r = dupstring(buf);`. `dupstring` uses `strlen`
    /// so the resulting string TRUNCATES at the first NUL byte —
    /// short strings of 1 or 2 chars get their tail NUL-padded and
    /// silently dropped by strlen.
    ///
    /// The previous Rust port used `retain(|&x| x != 0)` which SPLICES
    /// OUT interior NULs (so `[a, 0, b]` would yield "ab" instead of
    /// C's "a"). Verify both endpoints work correctly:
    ///   * 1-char string ("a", 0, 0)        → "a"   (strlen-truncate)
    ///   * 2-char string ("ab", 0)          → "ab"  (strlen-truncate)
    ///   * 3-char string ("abc")            → "abc" (full)
    ///   * pathological ("a", 0, "b")       → "a"   (NOT "ab")
    #[test]
    fn ecgetstr_inline_string_truncates_at_first_nul_like_c_strlen() {
        let _g = crate::test_util::global_state_lock();
        // Build a wordcode word with `c & 2 != 0` (inline-string flag)
        // and the 3 bytes packed at offsets 3, 11, 19. `c & 1` is the
        // tokflag; clear it for this test.
        fn pack_inline(b0: u8, b1: u8, b2: u8) -> u32 {
            // c:2862 layout — bit0 = tokflag (0 here), bit1 = inline (1),
            // bits 3-10 = b0, bits 11-18 = b1, bits 19-26 = b2.
            (2u32) | ((b0 as u32) << 3) | ((b1 as u32) << 11) | ((b2 as u32) << 19)
        }
        let mk_state = |word: u32| -> estate {
            let p = eprog {
                flags: 0,
                len: 1,
                npats: 0,
                nref: 0,
                pats: Vec::new(),
                prog: vec![word],
                strs: None,
                shf: None,
                dump: None,
                strs_metafied: false, // no pool (strs: None) — flag unused
            };
            estate {
                prog: Box::new(p),
                pc: 0,
                strs: None,
                strs_offset: 0,
            }
        };

        // 1-char: ('a', 0, 0) → "a"
        let mut st = mk_state(pack_inline(b'a', 0, 0));
        assert_eq!(
            ecgetstr(&mut st, 0, None),
            "a",
            "c:2869 strlen truncates 1-char inline at the NUL tail"
        );

        // 2-char: ('a', 'b', 0) → "ab"
        let mut st = mk_state(pack_inline(b'a', b'b', 0));
        assert_eq!(
            ecgetstr(&mut st, 0, None),
            "ab",
            "c:2869 strlen truncates 2-char inline at the NUL tail"
        );

        // 3-char: ('a', 'b', 'c') → "abc"
        let mut st = mk_state(pack_inline(b'a', b'b', b'c'));
        assert_eq!(
            ecgetstr(&mut st, 0, None),
            "abc",
            "c:2869 full 3-byte inline preserved"
        );

        // Pathological: ('a', 0, 'b') → "a" (NOT "ab" from retain-splice)
        let mut st = mk_state(pack_inline(b'a', 0, b'b'));
        assert_eq!(
            ecgetstr(&mut st, 0, None),
            "a",
            "c:2869 strlen STOPS at first NUL; must not splice 'b' through"
        );
    }

    /// Pin: `init_parse_status` resets ALL six lexer-parser flags
    /// per `Src/parse.c:500-502`. Specifically `inrepeat_ = 0` at
    /// c:501 was previously missing in the Rust port. Pin every
    /// reset so a future regression that drops one is caught.
    #[test]
    fn init_parse_status_resets_all_lexer_parser_flags() {
        let _g = crate::test_util::global_state_lock();
        // Dirty every flag to a non-default value.
        set_incasepat(5);
        set_incond(7);
        set_inredir(true);
        set_infor(3);
        set_intypeset(true);
        set_inrepeat(2);
        set_incmdpos(false);
        // Reset.
        init_parse_status();
        // c:500-502 — every flag back to its default.
        assert_eq!(incasepat(), 0, "c:500 — incasepat = 0");
        assert_eq!(incond(), 0, "c:500 — incond = 0");
        assert!(!inredir(), "c:500 — inredir = 0");
        assert_eq!(infor(), 0, "c:500 — infor = 0");
        assert!(!intypeset(), "c:500 — intypeset = 0");
        assert_eq!(
            inrepeat(),
            0,
            "c:501 — inrepeat_ = 0 (was previously missing)"
        );
        assert!(incmdpos(), "c:502 — incmdpos = 1");
    }

    // ═══════════════════════════════════════════════════════════════════
    // AST shape tests — feed source through parse(), walk the resulting
    // ZshProgram, assert structural properties. Each test uses the local
    // `parse(input)` helper that errors cleanly on parse failure.
    // Anchor: where applicable, behavior matches `zsh -n -c '...'`
    // (parse-only, no execution — which would error on syntax issues).
    // ═══════════════════════════════════════════════════════════════════

    /// Empty input → ZshProgram with no lists.
    #[test]
    fn parse_empty_source_yields_zero_lists() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("").unwrap();
        assert_eq!(prog.lists.len(), 0);
    }

    /// Comment-only input → no lists (comments are skipped at lex level).
    #[test]
    fn parse_only_comment_yields_zero_lists() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("# this is just a comment").unwrap();
        assert_eq!(prog.lists.len(), 0, "comments alone produce no cmds");
    }

    /// Three commands separated by `;` → three lists.
    #[test]
    fn parse_three_semicolon_separated_commands_yield_three_lists() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("a; b; c").unwrap();
        assert_eq!(prog.lists.len(), 3);
    }

    /// Background command — async flag set on the list.
    #[test]
    fn parse_background_command_sets_async_flag() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("sleep 1 &").unwrap();
        assert_eq!(prog.lists.len(), 1);
        assert!(
            prog.lists[0].flags.async_,
            "trailing `&` must set async_ flag"
        );
    }

    /// Pipe count: `a | b | c | d` → 4 stages.
    #[test]
    fn parse_four_stage_pipeline_has_three_next_links() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("a | b | c | d").unwrap();
        let mut pipe = &prog.lists[0].sublist.pipe;
        let mut count = 1;
        while let Some(next) = &pipe.next {
            pipe = next;
            count += 1;
        }
        assert_eq!(count, 4, "4 commands should produce 4 pipe stages");
    }

    /// `|&` between pipeline stages sets merge_stderr.
    #[test]
    fn parse_pipe_amp_sets_merge_stderr() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("a |& b").unwrap();
        let pipe = &prog.lists[0].sublist.pipe;
        assert!(pipe.next.is_some());
        assert!(pipe.merge_stderr, "|& must set merge_stderr");
    }

    /// `cmd1 || cmd2`: sublist.next is Some with `Or`.
    #[test]
    fn parse_or_operator_sets_sublist_op_or() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("cmd1 || cmd2").unwrap();
        let sublist = &prog.lists[0].sublist;
        let (op, _) = sublist.next.as_ref().expect("must have next");
        assert_eq!(*op, SublistOp::Or);
    }

    /// `! cmd` sets the not flag on the sublist.
    #[test]
    fn parse_bang_negation_sets_sublist_not_flag() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("! false").unwrap();
        let sublist = &prog.lists[0].sublist;
        assert!(sublist.flags.not, "`!` prefix must set sublist.flags.not");
    }

    // ── Compound commands ────────────────────────────────────────────
    /// `while cond; do body; done` → ZshCommand::While.
    #[test]
    fn parse_while_loop_yields_while_command() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("while true; do echo x; done").unwrap();
        assert!(matches!(
            prog.lists[0].sublist.pipe.cmd,
            ZshCommand::While(_)
        ));
    }

    /// `until cond; do body; done` → ZshCommand::Until.
    /// Anchor: `zsh -n -c 'until false; do echo; done'` accepts and parses
    /// as an until-loop. zshrs accepts but emits a DIFFERENT AST variant
    /// (not Until). Bug — until loop is mis-classified.
    #[test]
    fn parse_until_loop_yields_until_command_anchored_to_zsh() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("until false; do echo x; done").unwrap();
        assert!(
            matches!(prog.lists[0].sublist.pipe.cmd, ZshCommand::Until(_)),
            "zsh parses `until` as Until variant; zshrs uses different variant: {:?}",
            prog.lists[0].sublist.pipe.cmd
        );
    }

    /// `(cmd)` → Subsh variant.
    #[test]
    fn parse_parens_yield_subsh_command() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("(echo hi)").unwrap();
        assert!(matches!(
            prog.lists[0].sublist.pipe.cmd,
            ZshCommand::Subsh(_)
        ));
    }

    /// `{ cmd; }` → Cursh (current-shell) command.
    #[test]
    fn parse_braces_yield_cursh_command() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("{ echo hi; }").unwrap();
        assert!(matches!(
            prog.lists[0].sublist.pipe.cmd,
            ZshCommand::Cursh(_)
        ));
    }

    /// `[[ a == b ]]` → ZshCommand::Cond.
    #[test]
    fn parse_double_brackets_yield_cond_command() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("[[ a == b ]]").unwrap();
        assert!(matches!(
            prog.lists[0].sublist.pipe.cmd,
            ZshCommand::Cond(_)
        ));
    }

    /// `(( 1 + 2 ))` → ZshCommand::Arith.
    #[test]
    fn parse_double_parens_yield_arith_command() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("(( 1 + 2 ))").unwrap();
        assert!(matches!(
            prog.lists[0].sublist.pipe.cmd,
            ZshCommand::Arith(_)
        ));
    }

    /// `repeat 3 do echo x; done` → ZshCommand::Repeat.
    #[test]
    fn parse_repeat_loop_yields_repeat_command() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("repeat 3 do echo x; done").unwrap();
        assert!(matches!(
            prog.lists[0].sublist.pipe.cmd,
            ZshCommand::Repeat(_)
        ));
    }

    // ── Function definitions ─────────────────────────────────────────
    /// `name() { body; }` → FuncDef variant.
    #[test]
    fn parse_paren_funcdef_yields_funcdef_command() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("greet() { echo hi; }").unwrap();
        assert!(matches!(
            prog.lists[0].sublist.pipe.cmd,
            ZshCommand::FuncDef(_)
        ));
    }

    /// `function name { body; }` → FuncDef variant (zsh keyword form).
    #[test]
    fn parse_function_keyword_funcdef_yields_funcdef_command() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("function greet { echo hi; }").unwrap();
        assert!(matches!(
            prog.lists[0].sublist.pipe.cmd,
            ZshCommand::FuncDef(_)
        ));
    }

    /// Syntax error — `if` without `fi` → parse returns Err.
    /// Anchor: `echo 'if true; then echo' | zsh -n` → "parse error".
    #[test]
    fn parse_unterminated_if_returns_error_anchored_to_zsh() {
        let _g = crate::test_util::global_state_lock();
        let r = parse("if true; then echo yes");
        assert!(r.is_err(), "zsh -n: parse error near `\\n`");
    }

    /// Syntax error — bare `done` without `for/while/until` → error.
    /// Anchor: `echo done | zsh -n` → "parse error near `done`".
    #[test]
    fn parse_orphan_done_returns_error_anchored_to_zsh() {
        let _g = crate::test_util::global_state_lock();
        let r = parse("done");
        assert!(r.is_err(), "zsh -n: parse error near `done`");
    }

    /// Simple command's words are metafied at the AST layer (matches
    /// zsh's internal representation: `-` lexes to `Dash` = 0x9b, `*`
    /// to `Star`, etc.). zsh untokenizes via `untokenize()` BEFORE
    /// surfacing words at execution time (Src/exec.c:execcmd_args).
    /// This test pins the round-trip: `untokenize(word)` recovers the
    /// user-visible form. If parse-time unmetafy ever lands the
    /// untokenize call becomes a no-op; the test stays green either
    /// way. Companion test below pins the metafied internal form.
    #[test]
    fn parse_simple_command_words_unmetafied_like_zsh_anchored() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("ls -la /tmp").unwrap();
        match &prog.lists[0].sublist.pipe.cmd {
            ZshCommand::Simple(s) => {
                let untok: Vec<String> = s
                    .words
                    .iter()
                    .map(|w| crate::ported::lex::untokenize(w))
                    .collect();
                assert_eq!(
                    untok,
                    vec!["ls", "-la", "/tmp"],
                    "untokenize(word) must yield the user-visible form"
                );
            }
            other => panic!("expected Simple, got {other:?}"),
        }
    }

    /// Pin the OBSERVED zshrs contract: simple-command word array
    /// contains metafied bytes. This is the active (passing) version
    /// of the anchor above — it documents zshrs's current internal
    /// representation. If zshrs starts unmetafying at parse time, this
    /// test will FAIL and the anchor-style test above will start passing.
    #[test]
    fn parse_simple_command_words_metafied_internal_form() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("ls -la /tmp").unwrap();
        match &prog.lists[0].sublist.pipe.cmd {
            ZshCommand::Simple(s) => {
                assert_eq!(s.words.len(), 3);
                assert_eq!(s.words[0], "ls");
                assert_eq!(s.words[2], "/tmp");
                // s.words[1] contains the metafied `-` (`\u{e19b}` Dash byte)
                // followed by "la". Don't pin the exact byte form (it
                // may change); pin that the length is right.
                assert_eq!(s.words[1].chars().count(), 3, "`-la` is 3 chars");
                assert!(s.words[1].ends_with("la"));
            }
            other => panic!("expected Simple, got {other:?}"),
        }
    }

    // ─── zsh-corpus pins for parser: structural shapes ────────────────

    /// Empty input — parse succeeds, lists may be empty.
    #[test]
    fn parse_corpus_empty_input_no_error() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("").unwrap();
        assert!(
            prog.lists.is_empty() || prog.lists.len() <= 1,
            "empty input → 0 or 1 list, got {}",
            prog.lists.len()
        );
    }

    /// Comment-only input parses as empty.
    #[test]
    fn parse_corpus_comment_only_no_error() {
        let _g = crate::test_util::global_state_lock();
        let r = parse("# just a comment");
        assert!(r.is_ok(), "comment-only parse should succeed");
    }

    /// `cmd1; cmd2` — two top-level lists or two sublists.
    #[test]
    fn parse_corpus_semicolon_separates_commands() {
        let _g = crate::test_util::global_state_lock();
        let prog = parse("echo a; echo b").unwrap();
        // We pin: parse produces > 0 lists/sublists; details vary.
        assert!(!prog.lists.is_empty(), "non-empty parse");
    }

    /// `a && b` — DAMPER joins into a sublist chain.
    #[test]
    fn parse_corpus_logical_and_parses() {
        let _g = crate::test_util::global_state_lock();
        let r = parse("true && false");
        assert!(r.is_ok(), "`a && b` parses cleanly");
    }

    /// `a || b` — DBAR.
    #[test]
    fn parse_corpus_logical_or_parses() {
        let _g = crate::test_util::global_state_lock();
        let r = parse("false || true");
        assert!(r.is_ok(), "`a || b` parses cleanly");
    }

    /// `a | b` pipeline.
    #[test]
    fn parse_corpus_pipeline_parses() {
        let _g = crate::test_util::global_state_lock();
        let r = parse("echo hi | cat");
        assert!(r.is_ok(), "`a | b` parses");
    }

    /// `if true; then echo x; fi` — basic if-then-fi block.
    #[test]
    fn parse_corpus_if_then_fi_parses() {
        let _g = crate::test_util::global_state_lock();
        let r = parse("if true; then echo x; fi");
        assert!(r.is_ok(), "if/then/fi parses cleanly");
    }

    /// `for i in 1 2 3; do echo $i; done`.
    #[test]
    fn parse_corpus_for_do_done_parses() {
        let _g = crate::test_util::global_state_lock();
        let r = parse("for i in 1 2 3; do echo $i; done");
        assert!(r.is_ok(), "for/do/done parses cleanly");
    }

    /// `while true; do break; done`.
    #[test]
    fn parse_corpus_while_do_done_parses() {
        let _g = crate::test_util::global_state_lock();
        let r = parse("while true; do break; done");
        assert!(r.is_ok(), "while/do/done parses cleanly");
    }

    /// `case x in (a) echo A;; esac` — case statement.
    #[test]
    fn parse_corpus_case_esac_parses() {
        let _g = crate::test_util::global_state_lock();
        let r = parse("case x in (a) echo A;; esac");
        assert!(r.is_ok(), "case/esac parses cleanly");
    }

    /// Function definition `f() { echo x }`.
    #[test]
    fn parse_corpus_function_def_parses() {
        let _g = crate::test_util::global_state_lock();
        let r = parse("f() { echo x }");
        assert!(r.is_ok(), "f() {{ ... }} parses cleanly");
    }

    /// `(subshell echo a)` — subshell.
    #[test]
    fn parse_corpus_subshell_parens_parses() {
        let _g = crate::test_util::global_state_lock();
        let r = parse("( echo a )");
        assert!(r.is_ok(), "subshell parses cleanly");
    }

    // ═══════════════════════════════════════════════════════════════════
    // C-parity tests pinning Src/parse.c. Tests that capture KNOWN
    // ZSHRS BUGS use #[ignore = "ZSHRS BUG: …"].
    // ═══════════════════════════════════════════════════════════════════

    /// `empty_eprog(p)` returns true on an eprog with empty `prog`.
    /// C `Src/parse.c:584`:
    ///   `return (!p || !p->prog || *p->prog == WCB_END());`
    /// Rust port at parse.rs:685 — `p.prog.is_empty() || p.prog[0] == WCB_END()`.
    #[test]
    fn empty_eprog_empty_prog_returns_true() {
        let _g = crate::test_util::global_state_lock();
        let p = crate::ported::zsh_h::eprog::default();
        assert!(empty_eprog(&p), "empty prog vec → empty_eprog true");
    }

    /// `empty_eprog(p)` returns true when first wordcode is WCB_END.
    /// C: `*p->prog == WCB_END()`.
    #[test]
    fn empty_eprog_first_wcb_end_returns_true() {
        let _g = crate::test_util::global_state_lock();
        let mut p = crate::ported::zsh_h::eprog::default();
        p.prog.push(WCB_END());
        assert!(empty_eprog(&p), "prog[0]==WCB_END → empty_eprog true");
    }

    /// `empty_eprog(p)` returns false for non-empty non-END prog.
    #[test]
    fn empty_eprog_non_empty_non_end_returns_false() {
        let _g = crate::test_util::global_state_lock();
        let mut p = crate::ported::zsh_h::eprog::default();
        // Push some non-END wordcode (1 is arbitrary non-zero, not WCB_END).
        p.prog.push(1);
        assert!(!empty_eprog(&p), "non-END first opcode → false");
    }

    /// `ecstrcode("")` returns a wordcode for the empty string. C
    /// `Src/parse.c:346-ish` ecstrcode interns strings in `ecbuf`.
    /// Pin: same call returns same wordcode (deterministic intern).
    #[test]
    fn ecstrcode_empty_string_returns_deterministic_code() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        let a = ecstrcode("");
        let b = ecstrcode("");
        assert_eq!(a, b, "intern of '' must be deterministic");
    }

    /// `ecstrcode` of two different strings returns different codes.
    #[test]
    fn ecstrcode_distinct_strings_get_distinct_codes() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        let a = ecstrcode("foo");
        let b = ecstrcode("bar");
        // Should differ — if equal, intern table collapsed two different
        // strings to the same key (bug).
        assert_ne!(a, b, "different strings must intern to different codes");
    }

    /// `parse_event(ENDINPUT)` on empty input returns None.
    /// C `Src/parse.c:715-ish` — empty token stream → no program.
    #[test]
    fn parse_event_empty_returns_none() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        // Empty input typically yields no program; needs lex state.
        let r = parse_event(crate::ported::lex::ENDINPUT);
        assert!(r.is_none(), "no tokens → no event");
    }

    // ═══════════════════════════════════════════════════════════════════
    // Additional C-parity tests for Src/parse.c.
    // ═══════════════════════════════════════════════════════════════════

    /// c:399 — `ecadd(c)` returns the index where `c` was placed,
    /// not the post-increment value. Sequential ecadd calls return
    /// strictly increasing indices.
    #[test]
    fn ecadd_returns_strictly_increasing_indices() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        let i0 = ecadd(0xDEAD);
        let i1 = ecadd(0xBEEF);
        let i2 = ecadd(0xC0DE);
        assert!(
            i1 > i0,
            "ecadd indices must strictly increase, got {i0} then {i1}"
        );
        assert!(
            i2 > i1,
            "ecadd indices must strictly increase, got {i1} then {i2}"
        );
        assert_eq!(i1, i0 + 1, "consecutive ecadds advance by 1");
        assert_eq!(i2, i1 + 1, "consecutive ecadds advance by 1");
    }

    /// c:413 — `ecdel(p)` removes one wordcode, shrinks ecused by 1.
    /// Pin: subsequent ecadd reuses freed slot (ecused decreased).
    #[test]
    fn ecdel_shrinks_ecused_by_one() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        let _i0 = ecadd(0xA);
        let i1 = ecadd(0xB);
        let _i2 = ecadd(0xC);
        let next_before = ECUSED.get();
        ecdel(i1);
        let next_after = ECUSED.get();
        assert_eq!(
            next_after,
            next_before - 1,
            "ecdel must decrement ecused by exactly 1"
        );
    }

    /// c:399-405 — `ecadd` after exhausting buffer must grow it (no
    /// panic on push past current eclen). Pin: 1000 adds don't crash.
    #[test]
    fn ecadd_grows_buffer_on_demand() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        for i in 0..1000 {
            ecadd(i as u32);
        }
        // No panic = grow path works.
        assert!(ECUSED.get() >= 1000, "1000 adds → ecused ≥ 1000");
    }

    /// c:426 — `ecstrcode` of short strings (≤4 bytes) returns a
    /// packed inline wordcode (not an offset into the string region).
    /// Pin: identical short strings get identical codes.
    #[test]
    fn ecstrcode_short_strings_are_deterministic() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        let a = ecstrcode("ab");
        let b = ecstrcode("ab");
        assert_eq!(a, b, "same short string must intern to same code");
    }

    /// c:426 — long strings (>4 bytes) hit the deduped string region.
    /// Pin: same long string returns same code on repeat (registry
    /// dedupes).
    #[test]
    fn ecstrcode_long_strings_dedupe_in_registry() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        let a = ecstrcode("a-much-longer-test-string");
        let b = ecstrcode("a-much-longer-test-string");
        assert_eq!(a, b, "registry must dedupe identical long strings");
    }

    /// `clear_hdocs()` is idempotent — calling twice in a row leaves
    /// HDOCS = None and LEX_HEREDOCS empty.
    #[test]
    fn clear_hdocs_is_idempotent() {
        let _g = crate::test_util::global_state_lock();
        clear_hdocs();
        clear_hdocs();
        HDOCS.with_borrow(|h| assert!(h.is_none(), "HDOCS must be None"));
        LEX_HEREDOCS.with_borrow(|v| assert!(v.is_empty(), "LEX_HEREDOCS must be empty"));
    }

    /// `init_parse()` resets parse state to known empty defaults.
    /// Multiple init_parse calls are safe (idempotent).
    #[test]
    fn init_parse_is_idempotent() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        init_parse();
        // No panic = pass.
    }

    /// `empty_eprog` returns true for a default-constructed eprog
    /// (empty prog vec).
    #[test]
    fn empty_eprog_true_for_empty_prog() {
        let _g = crate::test_util::global_state_lock();
        let p = eprog {
            prog: Vec::new(),
            ..Default::default()
        };
        assert!(empty_eprog(&p), "empty prog vec → empty eprog");
    }

    /// `empty_eprog` returns true when prog[0] == WCB_END().
    #[test]
    fn empty_eprog_true_for_end_only_prog() {
        let _g = crate::test_util::global_state_lock();
        let p = eprog {
            prog: vec![WCB_END()],
            ..Default::default()
        };
        assert!(empty_eprog(&p), "WCB_END as first opcode → empty");
    }

    /// `ecadjusthere(p, d)` is safe to call when HDOCS is None.
    #[test]
    fn ecadjusthere_safe_when_hdocs_none() {
        let _g = crate::test_util::global_state_lock();
        clear_hdocs();
        // No panic = pass.
        ecadjusthere(0, 0);
        ecadjusthere(100, -5);
        ecadjusthere(0, 10);
    }

    /// `ecispace(p, n)` with n=0 is a no-op.
    #[test]
    fn ecispace_zero_n_is_noop() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        let before = ECUSED.get();
        ecispace(0, 0);
        let after = ECUSED.get();
        assert_eq!(before, after, "ecispace(_, 0) must not advance ecused");
    }

    // ═══════════════════════════════════════════════════════════════════
    // Additional C-parity tests for Src/parse.c
    // c:146 parse_context_save / c:191 parse_context_restore /
    // c:225 ecadjusthere / c:293 ecadd / c:346 ecstrcode / c:574 init_parse /
    // c:685 empty_eprog / c:693 clear_hdocs / c:786 parse_list / c:815 parse_cond
    // c:2234 par_wordlist / c:2249 par_nl_wordlist
    // ═══════════════════════════════════════════════════════════════════

    /// c:293 — `ecadd` returns usize (compile-time type pin).
    #[test]
    fn ecadd_returns_usize_type() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        let _: usize = ecadd(0);
    }

    /// c:346 — `ecstrcode` returns u32 (compile-time type pin).
    #[test]
    fn ecstrcode_returns_u32_type() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        let _: u32 = ecstrcode("");
    }

    /// c:346 — `ecstrcode("")` empty string is safe.
    #[test]
    fn ecstrcode_empty_string_no_panic() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        let _ = ecstrcode("");
    }

    /// c:346 — `ecstrcode` is deterministic for same input.
    #[test]
    fn ecstrcode_is_deterministic() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        for s in ["", "a", "abc", "hello world"] {
            let first = ecstrcode(s);
            for _ in 0..3 {
                assert_eq!(
                    ecstrcode(s),
                    first,
                    "ecstrcode({:?}) must be deterministic",
                    s
                );
            }
        }
    }

    /// c:786 — `parse_list` returns Option<eprog>.
    #[test]
    fn parse_list_returns_option_eprog_type() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        let _: Option<eprog> = parse_list();
    }

    /// c:815 — `parse_cond` returns Option<eprog>.
    #[test]
    fn parse_cond_returns_option_eprog_type() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        let _: Option<eprog> = parse_cond();
    }

    /// c:2234 — `par_wordlist` returns Vec<String>.
    #[test]
    fn par_wordlist_returns_vec_string_type() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        let _: Vec<String> = par_wordlist();
    }

    /// c:2249 — `par_nl_wordlist` returns Vec<String>.
    #[test]
    fn par_nl_wordlist_returns_vec_string_type() {
        let _g = crate::test_util::global_state_lock();
        init_parse();
        let _: Vec<String> = par_nl_wordlist();
    }

    /// c:693 — `clear_hdocs` deterministic state after call (no-panic).
    #[test]
    fn clear_hdocs_deterministic_after_call() {
        let _g = crate::test_util::global_state_lock();
        clear_hdocs();
        clear_hdocs();
    }

    /// c:225 — `ecadjusthere(0, 0)` is a no-op (no delta).
    #[test]
    fn ecadjusthere_zero_delta_no_panic() {
        let _g = crate::test_util::global_state_lock();
        ecadjusthere(0, 0);
    }

    /// c:225 — `ecadjusthere` is safe for arbitrary positions.
    #[test]
    fn ecadjusthere_arbitrary_pos_no_panic() {
        let _g = crate::test_util::global_state_lock();
        for p in [0usize, 1, 100, 9999] {
            ecadjusthere(p, 0);
            ecadjusthere(p, 1);
            ecadjusthere(p, -1);
        }
    }

    // ═══════════════════════════════════════════════════════════════════
    // Additional C-parity tests for Src/parse.c FD_* accessors
    // c:3127 fdmagic / c:3131 fdflags / c:3133 fdother / c:3140 fdversion /
    // c:3145 fdhflags / c:3146 fdhtail / c:3147 fdhbldflags
    // ═══════════════════════════════════════════════════════════════════

    fn build_fd_header() -> Vec<u32> {
        let mut buf = vec![0u32; FD_PRELEN + 32];
        buf[0] = FD_MAGIC; // pre[0] magic
        buf[1] = (0x12u32) | (0x00ABCDEFu32 << 8); // flags=0x12, other=0xABCDEF
                                                   // Embed version string starting at pre[2].
        let ver = b"5.9\0";
        for (i, chunk) in ver.chunks(4).enumerate() {
            let mut word = [0u8; 4];
            word[..chunk.len()].copy_from_slice(chunk);
            buf[2 + i] = u32::from_le_bytes(word);
        }
        buf[FD_PRELEN - 1] = (FD_PRELEN as u32) + 8; // header-len slot
        buf
    }

    /// c:3127 — `fdmagic(f)` returns pre[0] verbatim.
    #[test]
    fn fdmagic_returns_pre_zero_word() {
        let buf = build_fd_header();
        assert_eq!(fdmagic(&buf), FD_MAGIC, "fdmagic = pre[0]");
    }

    /// c:3131 — `fdflags` extracts low byte of pre[1].
    #[test]
    fn fdflags_low_byte_extraction() {
        let buf = build_fd_header();
        assert_eq!(fdflags(&buf), 0x12, "flags = pre[1] & 0xff");
    }

    /// c:3133 — `fdother` extracts high 24 bits of pre[1].
    #[test]
    fn fdother_high_24_bits_extraction() {
        let buf = build_fd_header();
        assert_eq!(
            fdother(&buf),
            0x00ABCDEF,
            "other = pre[1] >> 8 & 0x00ffffff"
        );
    }

    /// c:3132 — `fdsetflags` writes low byte, preserves high 24 bits.
    #[test]
    fn fdsetflags_preserves_high_24_bits() {
        let mut buf = build_fd_header();
        let other_before = fdother(&buf);
        fdsetflags(&mut buf, 0x42);
        assert_eq!(fdflags(&buf), 0x42, "new flags written");
        assert_eq!(fdother(&buf), other_before, "high 24 bits preserved");
    }

    /// c:3134 — `fdsetother` writes high 24 bits, preserves low byte.
    #[test]
    fn fdsetother_preserves_low_byte() {
        let mut buf = build_fd_header();
        let flags_before = fdflags(&buf);
        fdsetother(&mut buf, 0x00DEADBE);
        assert_eq!(fdother(&buf), 0x00DEADBE, "new other written");
        assert_eq!(fdflags(&buf), flags_before, "low byte preserved");
    }

    /// c:3134 — `fdsetother` clamps to 24 bits (caller-passed high bits dropped).
    #[test]
    fn fdsetother_clamps_to_24_bits() {
        let mut buf = build_fd_header();
        fdsetother(&mut buf, 0xFF_FFFF_FF);
        // Only the low 24 bits land in `other`.
        assert_eq!(fdother(&buf), 0x00FF_FFFF, "high bits dropped");
    }

    /// c:3140 — `fdversion(buf)` returns String (compile-time type pin).
    #[test]
    fn fdversion_returns_string_type() {
        let buf = build_fd_header();
        let _: String = fdversion(&buf);
    }

    /// c:3140 — `fdversion` reads the NUL-terminated string from pre[2..].
    #[test]
    fn fdversion_reads_until_nul() {
        let buf = build_fd_header();
        assert_eq!(fdversion(&buf), "5.9", "version read until NUL");
    }

    /// c:3145 — `fdhflags(h)` returns low 2 bits of flags.
    #[test]
    fn fdhflags_low_two_bits() {
        let h = fdhead {
            start: 0,
            len: 0,
            npats: 0,
            strs: 0,
            hlen: 0,
            flags: 0b1011, // tail=2, kshload bits = 0b11
        };
        assert_eq!(fdhflags(&h), 0b11, "flags = h.flags & 0x3");
    }

    /// c:3146 — `fdhtail(h)` returns high 30 bits (shifted right by 2).
    #[test]
    fn fdhtail_shift_right_two() {
        let h = fdhead {
            start: 0,
            len: 0,
            npats: 0,
            strs: 0,
            hlen: 0,
            flags: (0x12_3456 << 2) | 0x3,
        };
        assert_eq!(fdhtail(&h), 0x12_3456, "tail = h.flags >> 2");
    }

    /// c:3147 — `fdhbldflags(flags, tail)` packs into single u32.
    #[test]
    fn fdhbldflags_packs_flags_low_tail_high() {
        let packed = fdhbldflags(0x3, 0x42);
        assert_eq!(packed & 0x3, 0x3, "low 2 bits = flags");
        assert_eq!(packed >> 2, 0x42, "high 30 bits = tail");
    }

    /// c:3145-3147 — `fdhflags(h)`+`fdhtail(h)` round-trip via fdhbldflags.
    #[test]
    fn fdh_round_trip_via_bldflags() {
        for (flags, tail) in [(0u32, 0u32), (1, 100), (2, 0xABC), (3, 0xFFFF)] {
            let packed = fdhbldflags(flags, tail);
            let h = fdhead {
                start: 0,
                len: 0,
                npats: 0,
                strs: 0,
                hlen: 0,
                flags: packed,
            };
            assert_eq!(fdhflags(&h), flags, "flags round-trips");
            assert_eq!(fdhtail(&h), tail, "tail round-trips");
        }
    }

    /// c:8271 — `firstfdhead_offset()` returns FD_PRELEN constant.
    #[test]
    fn firstfdhead_offset_returns_prelen() {
        assert_eq!(
            firstfdhead_offset(),
            FD_PRELEN,
            "first header starts after prelude"
        );
    }

    /// c:3127 — `fdmagic` differentiates FD_MAGIC from FD_OMAGIC.
    #[test]
    fn fdmagic_differentiates_magic_omagic() {
        let mut buf = vec![FD_MAGIC; FD_PRELEN];
        assert_eq!(fdmagic(&buf), FD_MAGIC);
        buf[0] = FD_OMAGIC;
        assert_eq!(fdmagic(&buf), FD_OMAGIC, "swapped magic readable");
        assert_ne!(FD_MAGIC, FD_OMAGIC, "the two magics differ");
    }
}