zshrs 0.11.18

//! `compctl.h` port — completion descriptor types + `CC_*` / `CCT_*`
//! flag constants used by the legacy `compctl` builtin.
//!
//! Port of `Src/Zle/compctl.h`. Canonical home for the four typedefs
//! (`Compctlp`/`Compctl`/`Compcond`/`Patcomp`) and the two flag-bit
//! families: 30 `CC_*` primary completion-target flags (mask) and 7
//! `CC_*` secondary flags (mask2), plus 14 `CCT_*` `-x` condition
//! types.
//!
//! C source: 4 typedefs + 4 structs (`compctlp`, `patcomp`,
//! `compcond`, `compctl`), 14 `CCT_*` constants (c:76-89), 30
//! primary `CC_*` constants (c:118-149), 7 secondary `CC_*` constants
//! (c:152-158). 0 functions.
//!
//! `compctl.rs` (the .c port) re-exports these via `pub use
//! super::compctl_h::*;` so existing `cc_flags::FILES` / `cct::POS`
//! call sites keep compiling alongside the C-canonical
//! `CC_FILES` / `CCT_POS` names.

// ---------------------------------------------------------------------------
// `-x` condition type constants (c:76-89).
// ---------------------------------------------------------------------------

pub const CCT_UNUSED: i32 = 0; // c:76
pub const CCT_POS: i32 = 1; // c:77
pub const CCT_CURSTR: i32 = 2; // c:78
pub const CCT_CURPAT: i32 = 3; // c:79
pub const CCT_WORDSTR: i32 = 4; // c:80
pub const CCT_WORDPAT: i32 = 5; // c:81
pub const CCT_CURSUF: i32 = 6; // c:82
pub const CCT_CURPRE: i32 = 7; // c:83
pub const CCT_CURSUB: i32 = 8; // c:84
pub const CCT_CURSUBC: i32 = 9; // c:85
pub const CCT_NUMWORDS: i32 = 10; // c:86
pub const CCT_RANGESTR: i32 = 11; // c:87
pub const CCT_RANGEPAT: i32 = 12; // c:88
pub const CCT_QUOTE: i32 = 13; // c:89

// ---------------------------------------------------------------------------
// Primary completion-target flags (`mask`, c:118-149).
// Each bit selects one completion-source kind (files, vars, jobs, ...)
// the compctl spec expands.
// ---------------------------------------------------------------------------

pub const CC_FILES: u64 = 1 << 0; // c:118
pub const CC_COMMPATH: u64 = 1 << 1; // c:119
pub const CC_REMOVE: u64 = 1 << 2; // c:120
pub const CC_OPTIONS: u64 = 1 << 3; // c:121
pub const CC_VARS: u64 = 1 << 4; // c:122
pub const CC_BINDINGS: u64 = 1 << 5; // c:123
pub const CC_ARRAYS: u64 = 1 << 6; // c:124
pub const CC_INTVARS: u64 = 1 << 7; // c:125
pub const CC_SHFUNCS: u64 = 1 << 8; // c:126
pub const CC_PARAMS: u64 = 1 << 9; // c:127
pub const CC_ENVVARS: u64 = 1 << 10; // c:128
pub const CC_JOBS: u64 = 1 << 11; // c:129
pub const CC_RUNNING: u64 = 1 << 12; // c:130
pub const CC_STOPPED: u64 = 1 << 13; // c:131
pub const CC_BUILTINS: u64 = 1 << 14; // c:132
pub const CC_ALREG: u64 = 1 << 15; // c:133
pub const CC_ALGLOB: u64 = 1 << 16; // c:134
pub const CC_USERS: u64 = 1 << 17; // c:135
pub const CC_DISCMDS: u64 = 1 << 18; // c:136
pub const CC_EXCMDS: u64 = 1 << 19; // c:137
pub const CC_SCALARS: u64 = 1 << 20; // c:138
pub const CC_READONLYS: u64 = 1 << 21; // c:139
pub const CC_SPECIALS: u64 = 1 << 22; // c:140
pub const CC_DELETE: u64 = 1 << 23; // c:141
pub const CC_NAMED: u64 = 1 << 24; // c:142
pub const CC_QUOTEFLAG: u64 = 1 << 25; // c:143
pub const CC_EXTCMDS: u64 = 1 << 26; // c:144
pub const CC_RESWDS: u64 = 1 << 27; // c:145
pub const CC_DIRS: u64 = 1 << 28; // c:146
pub const CC_EXPANDEXPL: u64 = 1 << 30; // c:148
pub const CC_RESERVED: u64 = 1 << 31; // c:149

// ---------------------------------------------------------------------------
// Secondary completion-target flags (`mask2`, c:152-158).
// ---------------------------------------------------------------------------

pub const CC_NOSORT: u64 = 1 << 0; // c:152
pub const CC_XORCONT: u64 = 1 << 1; // c:153
pub const CC_CCCONT: u64 = 1 << 2; // c:154
pub const CC_PATCONT: u64 = 1 << 3; // c:155
pub const CC_DEFCONT: u64 = 1 << 4; // c:156
pub const CC_UNIQCON: u64 = 1 << 5; // c:157
pub const CC_UNIQALL: u64 = 1 << 6; // c:158

// ---------------------------------------------------------------------------
// Typedef structs (c:32-115).
//
// C uses linked lists threaded through `next` pointers. The Rust
// port substitutes `Option<Box<...>>` for the same self-referential
// chain; the linked-list semantics are preserved.
// ---------------------------------------------------------------------------

/// Port of `struct compctlp` from `Src/Zle/compctl.h:39-42`. Hash
/// table node entry holding a pointer to the compctl descriptor.
///
/// C definition (c:39-42):
/// ```c
/// struct compctlp {
///     struct hashnode node;
///     Compctl cc;
/// };
/// ```
///
/// The Rust port omits the `hashnode` head (zshrs's hashtable
/// machinery threads name+next through a separate scaffold) and
/// keeps the semantic payload — a pointer to the compctl descriptor.
#[derive(Debug, Clone)]
#[allow(non_camel_case_types)]
pub struct Compctlp {
    // c:39
    pub cc: std::sync::Arc<Compctl>, // c:41
}

/// Port of `struct patcomp` from `Src/Zle/compctl.h:46-50`. Linked-
/// list node for the pattern-compctl registry (entries created by
/// `compctl -p PATTERN ...`).
///
/// C definition (c:46-50):
/// ```c
/// struct patcomp {
///     Patcomp next;
///     char *pat;
///     Compctl cc;
/// };
/// ```
#[derive(Debug, Clone)]
#[allow(non_camel_case_types)]
pub struct Patcomp {
    // c:46
    pub next: Option<Box<Patcomp>>,  // c:47
    pub pat: String,                 // c:48
    pub cc: std::sync::Arc<Compctl>, // c:49
}

/// Port of `struct compcond` from `Src/Zle/compctl.h:54-74`. The
/// per-condition descriptor for `compctl -x`.
///
/// C definition (c:54-74):
/// ```c
/// struct compcond {
///     Compcond and, or;
///     int type;            /* one of CCT_* */
///     int n;               /* array length */
///     union {
///         struct { int *a, *b; } r;       /* CCT_POS, CCT_NUMWORDS */
///         struct { int *p; char **s; } s;  /* CCT_CURSTR, CCT_CURPAT, ... */
///         struct { char **a, **b; } l;     /* CCT_RANGESTR, ... */
///     } u;
/// };
/// ```
///
/// The Rust port collapses C's `union` into an explicit enum
/// (`CompcondData`) since Rust unions require unsafe; the dispatch
/// is by `typ` per the C convention.
#[derive(Debug, Clone, Default)]
#[allow(non_camel_case_types)]
pub struct Compcond {
    // c:54
    pub and: Option<Box<Compcond>>, // c:55
    pub or: Option<Box<Compcond>>,  // c:55
    pub typ: i32,                   // c:56  (Rust keyword `type`)
    pub n: i32,                     // c:57
    pub u: CompcondData,            // c:58 union
}

/// Port of the anonymous `union { struct r,s,l }` inside `compcond`
/// at `Src/Zle/compctl.h:58-73`. The C union is dispatched by
/// `typ` (one of the `CCT_*` constants).
#[derive(Debug, Clone, Default)]
#[allow(non_camel_case_types)]
pub enum CompcondData {
    // c:58
    /// Port of `struct { int *a, *b; } r` (c:59-62) — used by
    /// `CCT_POS`, `CCT_NUMWORDS`.
    R { a: Vec<i32>, b: Vec<i32> },
    /// Port of `struct { int *p; char **s; } s` (c:63-66) — used by
    /// `CCT_CURSTR`, `CCT_CURPAT`, `CCT_CURSUF`, `CCT_CURPRE`,
    /// `CCT_CURSUB`, `CCT_CURSUBC`, `CCT_WORDSTR`, `CCT_WORDPAT`,
    /// `CCT_QUOTE`.
    S { p: Vec<i32>, s: Vec<String> },
    /// Port of `struct { char **a, **b; } l` (c:68-71) — used by
    /// `CCT_RANGESTR`, `CCT_RANGEPAT`.
    L { a: Vec<String>, b: Vec<String> },
    /// Empty (CCT_UNUSED).
    #[default]
    Unused,
}

/// Port of `struct compctl` from `Src/Zle/compctl.h:93-115`. The
/// real per-command compctl descriptor — what `compctl name args`
/// allocates and registers in the `compctltab` hashtable.
///
/// C definition (c:93-115) — 22 fields. Field names + types
/// preserved verbatim; pointer types collapse to `Option<String>` /
/// `Option<std::sync::Arc<Compctl>>` etc. as appropriate.
#[derive(Debug, Clone, Default)]
#[allow(non_camel_case_types)]
pub struct Compctl {
    // c:93
    /// Reference count.
    pub refc: i32, // c:94
    /// Next compctl in a `-x` chain.
    pub next: Option<std::sync::Arc<Compctl>>, // c:95
    /// Mask of completion-target flags (`CC_*`).
    pub mask: u64, // c:96
    /// Secondary mask of completion-target flags (`CC_*`, mask2).
    pub mask2: u64, // c:96
    /// `-k` variable name.
    pub keyvar: Option<String>, // c:97
    /// `-g` glob pattern.
    pub glob: Option<String>, // c:98
    /// `-s` expansion string.
    pub str: Option<String>, // c:99 (Rust keyword `str`)
    /// `-K` function name.
    pub func: Option<String>, // c:100
    /// `-X` explanation.
    pub explain: Option<String>, // c:101
    /// `-y` user-defined description for listing.
    pub ylist: Option<String>, // c:102
    /// `-P` prefix.
    pub prefix: Option<String>, // c:103
    /// `-S` suffix.
    pub suffix: Option<String>, // c:103
    /// `-l` command name to use.
    pub subcmd: Option<String>, // c:104
    /// `-1` command name to use.
    pub substr: Option<String>, // c:105
    /// `-w` with-directory.
    pub withd: Option<String>, // c:106
    /// `-H` history pattern.
    pub hpat: Option<String>, // c:107
    /// `-H` number of events to search.
    pub hnum: i32, // c:108
    /// `-J`/`-V` group name.
    pub gname: Option<String>, // c:109
    /// `-x` first compctl in the chain.
    pub ext: Option<std::sync::Arc<Compctl>>, // c:110
    /// `-x` condition for this compctl.
    pub cond: Option<Box<Compcond>>, // c:111
    /// `+` xor'ed compctl chain.
    pub xor: Option<std::sync::Arc<Compctl>>, // c:112
    /// `-M` matcher control — head of the Cmatcher chain compiled
    /// from this compctl's match-spec arg.
    pub matcher: Option<Box<crate::ported::zle::comp_h::Cmatcher>>, // c:113
    /// `-M` matcher string.
    pub mstr: Option<String>, // c:114
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ported::zle::zle_main::zle_test_setup;

    /// Verifies CCT_* values per c:76-89.
    #[test]
    fn cct_constants_correct() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        assert_eq!(CCT_UNUSED, 0);
        assert_eq!(CCT_POS, 1);
        assert_eq!(CCT_CURSTR, 2);
        assert_eq!(CCT_QUOTE, 13);
    }

    /// Verifies CC_* primary mask values per c:118-149 — single-bit,
    /// non-overlapping.
    #[test]
    fn cc_primary_mask_bits_distinct() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        let all = CC_FILES
            | CC_COMMPATH
            | CC_REMOVE
            | CC_OPTIONS
            | CC_VARS
            | CC_BINDINGS
            | CC_ARRAYS
            | CC_INTVARS
            | CC_SHFUNCS
            | CC_PARAMS
            | CC_ENVVARS
            | CC_JOBS
            | CC_RUNNING
            | CC_STOPPED
            | CC_BUILTINS
            | CC_ALREG
            | CC_ALGLOB
            | CC_USERS
            | CC_DISCMDS
            | CC_EXCMDS
            | CC_SCALARS
            | CC_READONLYS
            | CC_SPECIALS
            | CC_DELETE
            | CC_NAMED
            | CC_QUOTEFLAG
            | CC_EXTCMDS
            | CC_RESWDS
            | CC_DIRS
            | CC_EXPANDEXPL
            | CC_RESERVED;
        assert_eq!(all.count_ones(), 31); // 30 sequential + 30 + 31 (skips bit 29)
    }

    /// Verifies the secondary mask values per c:152-158.
    #[test]
    fn cc_secondary_mask_values() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        assert_eq!(CC_NOSORT, 1);
        assert_eq!(CC_XORCONT, 2);
        assert_eq!(CC_UNIQALL, 1 << 6);
    }

    /// Verifies Compctl Default initialiser zeroes every field per
    /// the C convention of `(Compctl) calloc(1, sizeof(...))`.
    #[test]
    fn compctl_default_zeros_fields() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        let cc = Compctl::default();
        assert_eq!(cc.refc, 0);
        assert!(cc.next.is_none());
        assert_eq!(cc.mask, 0);
        assert_eq!(cc.mask2, 0);
        assert!(cc.keyvar.is_none());
        assert!(cc.cond.is_none());
        assert!(cc.xor.is_none());
        assert_eq!(cc.hnum, 0);
    }

    /// Verifies Compcond Default starts in CCT_UNUSED state.
    #[test]
    fn compcond_default_is_unused() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        let c = Compcond::default();
        assert_eq!(c.typ, CCT_UNUSED);
        assert!(matches!(c.u, CompcondData::Unused));
    }

    /// Verifies the CompcondData variants align with the C union
    /// dispatch per c:58-73.
    #[test]
    fn compcond_data_variants() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        let r = CompcondData::R {
            a: vec![0, 1],
            b: vec![2, 3],
        };
        if let CompcondData::R { a, b } = r {
            assert_eq!(a, vec![0, 1]);
            assert_eq!(b, vec![2, 3]);
        } else {
            panic!("expected R variant");
        }
        let s = CompcondData::S {
            p: vec![1],
            s: vec!["x".into()],
        };
        assert!(matches!(s, CompcondData::S { .. }));
        let l = CompcondData::L {
            a: vec!["lo".into()],
            b: vec!["hi".into()],
        };
        assert!(matches!(l, CompcondData::L { .. }));
    }

    /// c:76-89 — Every CCT_* constant is a unique non-negative
    /// integer. Pin uniqueness so a copy-paste regen doesn't double
    /// up a tag (which would silently route two different
    /// completion-condition kinds through the same dispatch arm).
    #[test]
    fn cct_constants_are_unique() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        let all = [
            CCT_UNUSED,
            CCT_POS,
            CCT_CURSTR,
            CCT_CURPAT,
            CCT_WORDSTR,
            CCT_WORDPAT,
            CCT_CURSUF,
            CCT_CURPRE,
            CCT_CURSUB,
            CCT_CURSUBC,
            CCT_NUMWORDS,
            CCT_RANGESTR,
            CCT_RANGEPAT,
            CCT_QUOTE,
        ];
        let unique: std::collections::HashSet<_> = all.iter().copied().collect();
        assert_eq!(unique.len(), all.len(), "duplicate CCT_* constant detected");
        for &v in &all {
            assert!(v >= 0, "CCT_* constants must be non-negative");
        }
    }

    /// c:76 — CCT_UNUSED MUST be 0. The C source uses zero-init as
    /// the implicit "no condition" sentinel; a regression that sets
    /// CCT_UNUSED = 1 would mark every just-allocated condition as
    /// CCT_POS by accident.
    #[test]
    fn cct_unused_is_zero() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(CCT_UNUSED, 0, "CCT_UNUSED must be the zero-init sentinel");
    }

    /// c:118-127 — CC_* primary-mask bits are distinct singletons.
    /// Pin the bit-packing because the c:152 "primary mask" vs
    /// c:154-158 "secondary mask" distinction relies on the primary
    /// bits all being non-overlapping.
    #[test]
    fn cc_primary_mask_bits_are_distinct_singletons() {
        let _g = crate::test_util::global_state_lock();
        let primary = [
            CC_FILES,
            CC_COMMPATH,
            CC_REMOVE,
            CC_OPTIONS,
            CC_VARS,
            CC_BINDINGS,
            CC_ARRAYS,
            CC_INTVARS,
            CC_SHFUNCS,
            CC_PARAMS,
            CC_ENVVARS,
        ];
        for &m in &primary {
            assert_eq!(
                m.count_ones(),
                1,
                "primary CC_ mask {} has {} bits set",
                m,
                m.count_ones()
            );
        }
        let mut all: u64 = 0;
        for &m in &primary {
            assert_eq!(all & m, 0, "primary CC_ mask {} overlaps", m);
            all |= m;
        }
    }

    /// c:108 — `Compctl::default()` Default impl produces an empty
    /// struct ready for population. After a default + manual field
    /// write, the other fields must remain at their zero-init values.
    #[test]
    fn compctl_default_partial_population_doesnt_clobber_other_fields() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        let mut cc = Compctl::default();
        cc.mask = CC_FILES;
        assert_eq!(cc.mask, CC_FILES);
        // Every OTHER field must still be at default
        assert_eq!(cc.refc, 0);
        assert!(cc.next.is_none());
        assert_eq!(cc.mask2, 0);
        assert!(cc.keyvar.is_none());
        assert!(cc.cond.is_none());
        assert_eq!(cc.hnum, 0);
    }

    /// `Compcond::default()` produces a CCT_UNUSED node with the
    /// `Unused` data variant. Pin the simultaneous shape so a
    /// regression that picks one but not the other (e.g. CCT_POS
    /// with Unused data) gets caught.
    #[test]
    fn compcond_default_typ_and_data_are_consistent() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        let c = Compcond::default();
        assert_eq!(c.typ, CCT_UNUSED, "tag must be UNUSED");
        assert!(
            matches!(c.u, CompcondData::Unused),
            "data must be CompcondData::Unused"
        );
    }

    /// c:118-149 — Full sweep of CC_* primary-mask bits 0..31. Each
    /// must occupy a distinct bit position. Catches a regen that
    /// renumbers two flags to the same shift.
    #[test]
    fn cc_primary_mask_full_sweep_no_overlap() {
        let _g = crate::test_util::global_state_lock();
        let primary = [
            CC_FILES,
            CC_COMMPATH,
            CC_REMOVE,
            CC_OPTIONS,
            CC_VARS,
            CC_BINDINGS,
            CC_ARRAYS,
            CC_INTVARS,
            CC_SHFUNCS,
            CC_PARAMS,
            CC_ENVVARS,
            CC_STOPPED,
            CC_BUILTINS,
            CC_ALREG,
            CC_ALGLOB,
            CC_USERS,
            CC_DISCMDS,
            CC_EXCMDS,
            CC_SCALARS,
            CC_READONLYS,
            CC_SPECIALS,
            CC_DELETE,
            CC_NAMED,
            CC_QUOTEFLAG,
            CC_EXTCMDS,
            CC_RESWDS,
            CC_DIRS,
            CC_EXPANDEXPL,
            CC_RESERVED,
        ];
        for &m in &primary {
            assert_eq!(
                m.count_ones(),
                1,
                "primary CC_ mask {:#x} must be single bit",
                m
            );
        }
        let mut all: u64 = 0;
        for &m in &primary {
            assert_eq!(all & m, 0, "CC_ mask {:#x} overlaps with previous flags", m);
            all |= m;
        }
    }

    /// c:148 — CC_EXPANDEXPL lives at bit 30 (NOT 29). Pin the
    /// gap-at-bit-29 because the C source documents the bit-29
    /// hole at c:147. A regen that "fills the gap" would shift
    /// every subsequent flag.
    #[test]
    fn cc_expandexpl_at_bit_30_skips_bit_29() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(
            CC_EXPANDEXPL,
            1 << 30,
            "c:148 — CC_EXPANDEXPL must be at bit 30 (bit 29 is the gap)"
        );
        // Verify nothing else IS bit 29
        let all_primary = [
            CC_FILES,
            CC_COMMPATH,
            CC_REMOVE,
            CC_OPTIONS,
            CC_VARS,
            CC_BINDINGS,
            CC_ARRAYS,
            CC_INTVARS,
            CC_SHFUNCS,
            CC_PARAMS,
            CC_ENVVARS,
            CC_STOPPED,
            CC_BUILTINS,
            CC_ALREG,
            CC_ALGLOB,
            CC_USERS,
            CC_DISCMDS,
            CC_EXCMDS,
            CC_SCALARS,
            CC_READONLYS,
            CC_SPECIALS,
            CC_DELETE,
            CC_NAMED,
            CC_QUOTEFLAG,
            CC_EXTCMDS,
            CC_RESWDS,
            CC_DIRS,
            CC_EXPANDEXPL,
            CC_RESERVED,
        ];
        let bit_29: u64 = 1 << 29;
        for &m in &all_primary {
            assert_ne!(
                m, bit_29,
                "no primary mask should occupy bit 29 (the documented gap)"
            );
        }
    }

    /// c:149 — CC_RESERVED is bit 31 (the high bit). Pin the
    /// boundary so a regen that extends into bit 32 (u64 vs i32
    /// confusion) gets caught.
    #[test]
    fn cc_reserved_is_bit_31() {
        let _g = crate::test_util::global_state_lock();
        assert_eq!(CC_RESERVED, 1u64 << 31);
    }

    /// c:152-158 — Secondary-mask (mask2) flags occupy bits 0-6 of
    /// their OWN namespace. They DELIBERATELY collide with primary
    /// mask values (CC_NOSORT = 1 = CC_FILES) — the dispatcher
    /// routes via the mask vs mask2 field.
    #[test]
    fn secondary_mask_collides_with_primary_by_design() {
        let _g = crate::test_util::global_state_lock();
        // CC_NOSORT (mask2 bit 0) and CC_FILES (mask bit 0) both = 1
        assert_eq!(
            CC_NOSORT, CC_FILES,
            "collision is intentional — different mask fields"
        );
        // CC_XORCONT (mask2 bit 1) and CC_COMMPATH (mask bit 1) both = 2
        assert_eq!(CC_XORCONT, CC_COMMPATH);
        // ... but mask2 has its own no-overlap structure
        let secondary = [
            CC_NOSORT, CC_XORCONT, CC_CCCONT, CC_PATCONT, CC_DEFCONT, CC_UNIQCON, CC_UNIQALL,
        ];
        let mut all: u64 = 0;
        for &m in &secondary {
            assert_eq!(
                m.count_ones(),
                1,
                "secondary CC_ mask {:#x} must be single bit",
                m
            );
            assert_eq!(
                all & m,
                0,
                "secondary {:#x} overlaps within mask2 namespace",
                m
            );
            all |= m;
        }
    }

    /// c:76-89 — CCT_* values are sequential (0..13). Pin the
    /// dense layout so a regen that introduces a gap silently
    /// breaks the dispatcher's `(type - CCT_POS)` subtraction.
    #[test]
    fn cct_values_are_sequential_zero_through_thirteen() {
        let _g = crate::test_util::global_state_lock();
        let in_order = [
            CCT_UNUSED,
            CCT_POS,
            CCT_CURSTR,
            CCT_CURPAT,
            CCT_WORDSTR,
            CCT_WORDPAT,
            CCT_CURSUF,
            CCT_CURPRE,
            CCT_CURSUB,
            CCT_CURSUBC,
            CCT_NUMWORDS,
            CCT_RANGESTR,
            CCT_RANGEPAT,
            CCT_QUOTE,
        ];
        for (i, &v) in in_order.iter().enumerate() {
            assert_eq!(
                v, i as i32,
                "CCT_ at position {} must be {}, got {}",
                i, i, v
            );
        }
    }
}