retex_engine/

scan.rs

//! Scanning numbers, dimensions, glue, keywords and token lists
//! (*TeX: The Program* §402–§486, e-TeX §1490ff, LuaTeX extensions).

use std::rc::Rc;

use retex_arith::{self as arith, MAX_DIMEN, UNITY};

use crate::Engine;
use crate::cmd::Cmd;
use crate::eqtb::Loc;
use crate::glue::{self, Glue};
use crate::hash::NO_CS;
use crate::input::{ScannerStatus, TokKind};
use crate::primitives_gen as pg;
use crate::token::{Token, TokenList};

/// The level of a scanned value (`cur_val_level`).
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
pub enum ValLevel {
    /// An integer.
    #[default]
    Int = 0,
    /// A dimension.
    Dimen = 1,
    /// Glue.
    Glue = 2,
    /// Muglue.
    Mu = 3,
    /// A font identifier.
    Ident = 4,
    /// A token list.
    Tok = 5,
}

/// Offset of register numbers in the modifier of register-like
/// commands defined by `\countdef` etc. (smaller modifiers are parameters).
pub const REG_OFFSET: u32 = 0x1_0000;

/// `register` modifiers.
#[allow(missing_docs)]
pub mod reg {
    pub const COUNT: u32 = 0;
    pub const ATTRIBUTE: u32 = 1;
    pub const DIMEN: u32 = 2;
    pub const SKIP: u32 = 3;
    pub const MUSKIP: u32 = 4;
}

/// `last_item` modifiers (LuaTeX numbering).
#[allow(missing_docs)]
pub mod last_item {
    pub const LAST_PENALTY: u32 = 0;
    pub const LAST_KERN: u32 = 2;
    pub const LAST_SKIP: u32 = 3;
    pub const LAST_NODE_TYPE: u32 = 4;
    pub const INPUT_LINE_NO: u32 = 5;
    pub const BADNESS: u32 = 6;
    pub const LAST_SAVED_BOX_RESOURCE_INDEX: u32 = 7;
    pub const LAST_SAVED_IMAGE_RESOURCE_INDEX: u32 = 8;
    pub const LAST_SAVED_IMAGE_RESOURCE_PAGES: u32 = 9;
    pub const LAST_X_POS: u32 = 10;
    pub const LAST_Y_POS: u32 = 11;
    pub const RANDOM_SEED: u32 = 12;
    pub const LUATEX_VERSION: u32 = 13;
    pub const ETEX_MINOR_VERSION: u32 = 14;
    pub const ETEX_VERSION: u32 = 15;
    pub const CURRENT_GROUP_LEVEL: u32 = 16;
    pub const CURRENT_GROUP_TYPE: u32 = 17;
    pub const CURRENT_IF_LEVEL: u32 = 18;
    pub const CURRENT_IF_TYPE: u32 = 19;
    pub const CURRENT_IF_BRANCH: u32 = 20;
    pub const GLUE_STRETCH_ORDER: u32 = 21;
    pub const GLUE_SHRINK_ORDER: u32 = 22;
    pub const ETEX_GLUE_STRETCH_ORDER: u32 = 23;
    pub const ETEX_GLUE_SHRINK_ORDER: u32 = 24;
    pub const FONT_CHAR_WD: u32 = 25;
    pub const FONT_CHAR_HT: u32 = 26;
    pub const FONT_CHAR_DP: u32 = 27;
    pub const FONT_CHAR_IC: u32 = 28;
    pub const PAR_SHAPE_LENGTH: u32 = 29;
    pub const PAR_SHAPE_INDENT: u32 = 30;
    pub const PAR_SHAPE_DIMEN: u32 = 31;
    pub const GLUE_STRETCH: u32 = 32;
    pub const GLUE_SHRINK: u32 = 33;
    pub const MU_TO_GLUE: u32 = 34;
    pub const GLUE_TO_MU: u32 = 35;
    pub const NUM_EXPR: u32 = 36;
    pub const DIM_EXPR: u32 = 38;
    pub const GLUE_EXPR: u32 = 39;
    pub const MU_EXPR: u32 = 40;
}

/// The LuaTeX version reported by `\luatexversion`.
pub const LUATEX_VERSION: i32 = 122;
/// `\luatexrevision`.
pub const LUATEX_REVISION: &str = "0";
/// `\eTeXversion`.
pub const ETEX_VERSION: i32 = 2;
/// `\eTeXminorversion`.
pub const ETEX_MINOR_VERSION: i32 = 6;
/// `\eTeXrevision`.
pub const ETEX_REVISION: &str = ".6";

impl Engine {
    // ----- small helpers ---------------------------------------------------

    /// Gets the next non-blank non-call token (TeX §406).
    pub fn get_nonblank_noncall(&mut self) {
        loop {
            self.get_x_token();
            if self.cur_cmd != Cmd::Spacer {
                break;
            }
        }
    }

    /// Gets the next non-blank token, expanding everything except
    /// protected macros (e-TeX's `get_x_or_protected` loop, used where an
    /// alignment looks for `\noalign` or `\omit`).
    pub fn get_nonblank_or_protected(&mut self) {
        loop {
            self.get_token();
            if self.cur_cmd <= Cmd::MAX_COMMAND {
                if self.cur_cmd == Cmd::Spacer {
                    continue;
                }
                return;
            }
            if self.cur_cmd >= Cmd::Call
                && self.cur_cmd < Cmd::EndTemplate
                && self
                    .eqtb
                    .meaning(self.cur_cs)
                    .mac
                    .as_ref()
                    .is_some_and(|m| m.protected)
            {
                return;
            }
            self.expand();
        }
    }

    /// Gets the next non-blank non-relax non-call token (§404).
    pub fn get_nonblank_nonrelax_noncall(&mut self) {
        loop {
            self.get_x_token();
            if self.cur_cmd != Cmd::Spacer && self.cur_cmd != Cmd::Relax {
                break;
            }
        }
    }

    /// Scans an optional space (§443).
    pub fn scan_optional_space(&mut self) {
        self.get_x_token();
        if self.cur_cmd != Cmd::Spacer {
            self.back_input();
        }
    }

    /// Scans a left brace, inserting one if missing (`scan_left_brace`).
    pub fn scan_left_brace(&mut self) {
        self.get_nonblank_nonrelax_noncall();
        if self.cur_cmd != Cmd::LeftBrace {
            self.print_err("Missing { inserted");
            self.help(&[
                "A left brace was mandatory here, so I've put one in.",
                "You might want to delete and/or insert some corrections",
                "so that I will find a matching right brace soon.",
                // LuaTeX drops TeX82's parentheses around this line.
                "If you're confused by all this, try typing `I}' now.",
            ]);
            self.back_error();
            self.cur_tok = Token::LEFT_BRACE;
            self.cur_cmd = Cmd::LeftBrace;
            self.cur_chr = '{' as u32;
            self.input.align_state += 1;
        }
    }

    /// Scans an optional `=` (`scan_optional_equals`).
    pub fn scan_optional_equals(&mut self) {
        self.get_nonblank_noncall();
        if self.cur_tok != Token::other('=' as u32) {
            self.back_input();
        }
    }

    /// Looks for a keyword (`scan_keyword`); letters match either case.
    pub fn scan_keyword(&mut self, s: &str) -> bool {
        // Keywords are short: the matched tokens stay on the stack.
        let mut matched = [Token(0); 32];
        let bytes = s.as_bytes();
        if bytes.len() > matched.len() {
            // A long keyword from Lua (`token.scan_keyword`).
            return self.scan_long_keyword(bytes);
        }
        let mut k = 0;
        while k < bytes.len() {
            self.get_x_token();
            let c = u32::from(bytes[k]);
            let upper = if bytes[k].is_ascii_lowercase() {
                c - 32
            } else {
                c
            };
            if self.cur_cs == NO_CS && (self.cur_chr == c || self.cur_chr == upper) {
                matched[k] = self.cur_tok;
                k += 1;
            } else if self.cur_cmd != Cmd::Spacer || k > 0 {
                self.back_input();
                if k > 0 {
                    self.back_list(Rc::from(&matched[..k]));
                }
                return false;
            }
        }
        true
    }

    /// [`Engine::scan_keyword`] for keywords too long for its buffer.
    #[cold]
    fn scan_long_keyword(&mut self, bytes: &[u8]) -> bool {
        let mut matched = Vec::new();
        while matched.len() < bytes.len() {
            self.get_x_token();
            let b = bytes[matched.len()];
            let c = u32::from(b);
            let upper = if b.is_ascii_lowercase() { c - 32 } else { c };
            if self.cur_cs == NO_CS && (self.cur_chr == c || self.cur_chr == upper) {
                matched.push(self.cur_tok);
            } else if self.cur_cmd != Cmd::Spacer || !matched.is_empty() {
                self.back_input();
                if !matched.is_empty() {
                    self.back_list(Rc::from(matched));
                }
                return false;
            }
        }
        true
    }

    /// Pushes a token list to be read again (`back_list`).
    pub fn back_list(&mut self, list: TokenList) {
        self.begin_token_list(list, TokKind::BackedUp);
    }

    /// Reports an inappropriate mu/non-mu mix (`mu_error`).
    pub fn mu_error(&mut self) {
        self.print_err("Incompatible glue units");
        self.help(&["I'm going to assume that 1mu=1pt when they're mixed."]);
        self.error();
    }

    // ----- integers ---------------------------------------------------------

    /// Scans a signed integer into `cur_val` (`scan_int`).
    #[inline]
    pub fn scan_int(&mut self) {
        self.get_nonblank_noncall();
        // Fast path: an internal quantity without a sign.
        if self.cur_cmd.is_internal() {
            self.scan_something_internal(ValLevel::Int, false);
        } else {
            self.scan_int_from_first();
        }
    }

    /// [`scan_int`](Self::scan_int) once the first non-blank token has been
    /// read.
    #[inline(never)]
    fn scan_int_from_first(&mut self) {
        let mut ok_so_far = true;
        // Get the next non-blank non-sign token.
        let mut negative = false;
        let mut first = true;
        loop {
            if !first {
                self.get_nonblank_noncall();
            }
            first = false;
            if self.cur_tok == Token::other('-' as u32) {
                negative = !negative;
                self.cur_tok = Token::other('+' as u32);
            }
            if self.cur_tok != Token::other('+' as u32) {
                break;
            }
        }
        if self.cur_tok == Token::other('`' as u32) {
            // An alphabetic constant.
            self.get_token();
            if self.cur_tok.0 < crate::token::CS_TOKEN_FLAG {
                self.cur_val = self.cur_chr as i32;
                if self.cur_cmd <= Cmd::RightBrace {
                    if self.cur_cmd == Cmd::RightBrace {
                        self.input.align_state += 1;
                    } else {
                        self.input.align_state -= 1;
                    }
                }
            } else {
                let cs = self.cur_tok.cs_id();
                self.cur_val = match self.hash.kind(cs) {
                    crate::hash::CsKind::Active(c) | crate::hash::CsKind::Single(c) => *c as i32,
                    _ => 0x11_0000,
                };
            }
            if self.cur_val > 0x10_FFFF {
                self.print_err("Improper alphabetic constant");
                self.help(&[
                    "A one-character control sequence belongs after a ` mark.",
                    "So I'm essentially inserting \\0 here.",
                ]);
                self.cur_val = '0' as i32;
                self.back_error();
            } else {
                self.scan_optional_space();
            }
        } else if self.cur_cmd.is_internal() {
            self.scan_something_internal(ValLevel::Int, false);
        } else if self.cur_cmd == Cmd::MathStyle {
            // LuaTeX: the style commands are numbers (0-7).
            self.cur_val = self.cur_chr as i32;
        } else {
            // A numeric constant.
            let mut radix: i64 = 10;
            let mut m: i64 = 214_748_364;
            if self.cur_tok == Token::other('\'' as u32) {
                radix = 8;
                m = 0o2000000000;
                self.get_x_token();
            } else if self.cur_tok == Token::other('"' as u32) {
                radix = 16;
                m = 0o1000000000;
                self.get_x_token();
            }
            let mut vacuous = true;
            let mut val: i64 = 0;
            loop {
                let t = self.cur_tok;
                let d: i64 = if !t.is_cs()
                    && t.cmd() == Cmd::OtherChar
                    && (0x30..=0x39).contains(&t.chr())
                    && i64::from(t.chr() - 0x30) < radix
                {
                    i64::from(t.chr() - 0x30)
                } else if radix == 16
                    && !t.is_cs()
                    && (t.cmd() == Cmd::Letter || t.cmd() == Cmd::OtherChar)
                    && (0x41..=0x46).contains(&t.chr())
                {
                    i64::from(t.chr() - 0x41 + 10)
                } else {
                    break;
                };
                vacuous = false;
                if val >= m && (val > m || d > 7 || radix != 10) {
                    if ok_so_far {
                        self.print_err("Number too big");
                        self.help(&[
                            "I can only go up to 2147483647='17777777777=\"7FFFFFFF,",
                            "so I'm using that number instead of yours.",
                        ]);
                        self.error();
                        val = i64::from(arith::INFINITY);
                        ok_so_far = false;
                    }
                } else {
                    val = val * radix + d;
                }
                self.get_x_token();
            }
            self.cur_val = val as i32;
            if vacuous {
                self.missing_number();
            } else if self.cur_cmd != Cmd::Spacer {
                self.back_input();
            }
        }
        if negative {
            self.cur_val = self.cur_val.wrapping_neg();
        }
    }

    /// Reports a missing number (TeX's "Express astonishment").
    fn missing_number(&mut self) {
        self.print_err("Missing number, treated as zero");
        self.help(&[
            "A number should have been here; I inserted `0'.",
            "(If you can't figure out why I needed to see a number,",
            "look up `weird error' in the index to The TeXbook.)",
        ]);
        self.back_error();
    }

    fn scan_limited(&mut self, max: i32, what: &str, help: &'static str) {
        self.scan_int();
        if self.cur_val < 0 || self.cur_val > max {
            self.print_err(&format!("Bad {what} ("));
            self.printer.print_int(self.cur_val.into());
            self.printer.print_char(')' as u32);
            self.help(&[help, "I changed this one to zero."]);
            self.int_error_zero();
        }
    }

    fn int_error_zero(&mut self) {
        self.error();
        self.cur_val = 0;
    }

    /// Scans a register number 0–65535 (LuaTeX's `scan_register_num`).
    pub fn scan_register_num(&mut self) {
        self.scan_limited(
            65535,
            "register code",
            "A register code must be between 0 and 65535.",
        );
    }

    /// Scans a character code 0–0x10FFFF (`scan_char_num`).
    pub fn scan_char_num(&mut self) {
        self.scan_limited(
            0x10_FFFF,
            "character code",
            "A character code must be between 0 and 1114111.",
        );
    }

    /// Scans a stream number for `\read`, `\openin`, `\ifeof` (0–15).
    pub fn scan_four_bit_int(&mut self) {
        self.scan_limited(
            15,
            "number",
            "Since I expected to read a number between 0 and 15,",
        );
    }

    /// Scans a stream number for `\ifeof` and `\read`; LuaTeX accepts any
    /// integer here and treats out-of-range streams as closed.
    pub fn scan_four_bit_int_or_more(&mut self) {
        self.scan_int();
    }

    /// Scans a math character for `\mathchardef`, `\mathchar` and
    /// `\mathaccent` (`scan_fifteen_bit_int`) and returns it as a
    /// `math_given` value; `cur_val` is the number `\the` reports.
    ///
    /// Observed in LuaTeX 1.22: numbers above `"8000` (math active) are read as packed
    /// math codes (class·2²¹ + family·2²⁴ + character, what `\mathcode`
    /// reports for `\Umathcode`s), so `\mathchardef\x\mathcode`c` works;
    /// a character beyond U+10FFFF is an "Invalid math code during >
    /// 0x8000 mathcode fallback", a negative number a "Bad mathchar".
    pub fn scan_math_given(&mut self) -> u32 {
        self.scan_int();
        let v = self.cur_val;
        let g = if v < 0 {
            self.print_err("Bad mathchar (");
            self.printer.print_int(v.into());
            self.printer.print_char(')' as u32);
            0
        } else if v <= 0x8000 {
            return v as u32;
        } else if crate::codes::math_char(v.into()) > 0x10FFFF {
            self.print_err("Invalid math code during > 0x8000 mathcode fallback");
            0
        } else {
            v as u32 | crate::codes::MATH_GIVEN_PACKED
        };
        if g == 0 {
            self.help(&["I'm going to use 0 instead of that illegal code value."]);
            self.error();
        }
        self.cur_val = crate::codes::math_given_report(g);
        g
    }

    /// Scans a 27-bit delimiter code (`scan_twenty_seven_bit_int`).
    pub fn scan_twenty_seven_bit_int(&mut self) {
        self.scan_int();
        if self.cur_val < 0 || self.cur_val > 0o777777777 {
            self.print_err("Bad delimiter code (");
            self.printer.print_int(self.cur_val.into());
            self.printer.print_char(')' as u32);
            self.help(&[
                "A numeric delimiter code must be between 0 and 2^{27}-1.",
                "I changed this one to zero.",
            ]);
            self.int_error_zero();
        }
    }

    /// Scans a math family number 0–255 (LuaTeX).
    pub fn scan_math_family(&mut self) {
        self.scan_limited(255, "number", "A family number must be between 0 and 255.");
    }

    /// Scans a category code 0–15.
    pub fn scan_category_code(&mut self) {
        self.scan_limited(
            15,
            "category code",
            "A category code must be between 0 and 15.",
        );
    }

    // ----- dimensions --------------------------------------------------------

    /// Scans a normal dimension (`scan_normal_dimen`).
    pub fn scan_normal_dimen(&mut self) {
        self.scan_dimen(false, false, false);
    }

    /// Scans a dimension (`scan_dimen`, §448). `mu`: units must be `mu`;
    /// `inf`: infinite units allowed; `shortcut`: `cur_val` already holds
    /// the integer part. Sets `cur_val`, and `cur_order` via the returned
    /// order.
    pub fn scan_dimen(&mut self, mu: bool, inf: bool, shortcut: bool) -> glue::GlueOrder {
        let mut f: i32 = 0;
        let mut arith_error = false;
        let mut cur_order = glue::NORMAL;
        let mut negative = false;
        'attach_sign: {
            if !shortcut {
                negative = false;
                loop {
                    self.get_nonblank_noncall();
                    if self.cur_tok == Token::other('-' as u32) {
                        negative = !negative;
                        self.cur_tok = Token::other('+' as u32);
                    }
                    if self.cur_tok != Token::other('+' as u32) {
                        break;
                    }
                }
                if self.cur_cmd.is_internal() {
                    if mu {
                        self.scan_something_internal(ValLevel::Mu, false);
                        if self.cur_val_level >= ValLevel::Glue {
                            self.cur_val = self.cur_glue.width;
                        }
                        if self.cur_val_level == ValLevel::Mu {
                            break 'attach_sign;
                        }
                        if self.cur_val_level != ValLevel::Int {
                            self.mu_error();
                        }
                    } else {
                        self.scan_something_internal(ValLevel::Dimen, false);
                        if self.cur_val_level == ValLevel::Dimen {
                            break 'attach_sign;
                        }
                    }
                } else {
                    self.back_input();
                    if self.cur_tok == Token::other(',' as u32) {
                        self.cur_tok = Token::other('.' as u32);
                    }
                    let mut radix10 = true;
                    if self.cur_tok != Token::other('.' as u32) {
                        self.scan_int_radix(&mut radix10);
                    } else {
                        self.cur_val = 0;
                    }
                    if self.cur_tok == Token::other(',' as u32) {
                        self.cur_tok = Token::other('.' as u32);
                    }
                    if radix10 && self.cur_tok == Token::other('.' as u32) {
                        // Scan decimal fraction.
                        let mut digits: Vec<u8> = Vec::new();
                        self.get_token(); // the point token is being re-scanned
                        loop {
                            self.get_x_token();
                            let t = self.cur_tok;
                            if t.is_cs()
                                || t.cmd() != Cmd::OtherChar
                                || !(0x30..=0x39).contains(&t.chr())
                            {
                                break;
                            }
                            if digits.len() < 17 {
                                digits.push((t.chr() - 0x30) as u8);
                            }
                        }
                        f = arith::round_decimals(&digits);
                        if self.cur_cmd != Cmd::Spacer {
                            self.back_input();
                        }
                    }
                }
            }
            if self.cur_val < 0 {
                negative = !negative;
                self.cur_val = self.cur_val.wrapping_neg();
            }
            // Scan units.
            'attach_fraction: {
                'done: {
                    if inf && self.scan_keyword("fi") {
                        cur_order = glue::FI;
                        while self.scan_keyword("l") {
                            if cur_order == glue::FILLL {
                                break;
                            }
                            cur_order += 1;
                        }
                        break 'attach_fraction;
                    }
                    // Units that are internal dimensions.
                    let save_cur_val = self.cur_val;
                    self.get_nonblank_noncall();
                    let v: i32;
                    if !self.cur_cmd.is_internal() {
                        self.back_input();
                        if mu {
                            // Scan for mu units.
                            if !self.scan_keyword("mu") {
                                self.print_err("Illegal unit of measure (");
                                self.printer.print_str("mu inserted)");
                                self.help(&[
                                    "The unit of measurement in math glue must be mu.",
                                    "To recover gracefully from this error, it's best to",
                                    "delete the erroneous units; e.g., type `2' to delete",
                                    "two letters. (See Chapter 27 of The TeXbook.)",
                                ]);
                                self.error();
                            }
                            break 'attach_fraction;
                        }
                        if self.scan_keyword("em") {
                            v = self.quad(self.eqtb.cur_font.val);
                            self.scan_optional_space();
                        } else if self.scan_keyword("ex") {
                            v = self.x_height(self.eqtb.cur_font.val);
                            self.scan_optional_space();
                        } else if self.scan_keyword("px") {
                            v = self.eqtb.dimen(pg::assign_dimen::PXDIMEN);
                            self.scan_optional_space();
                        } else {
                            // Not an internal unit.
                            if self.scan_keyword("true") {
                                self.prepare_mag();
                                let mag = self.eqtb.int(pg::assign_int::MAG);
                                if mag != 1000 {
                                    match arith::xn_over_d(self.cur_val, 1000, mag) {
                                        Ok(r) => {
                                            self.cur_val = r.quotient;
                                            f = ((1000 * i64::from(f)
                                                + 0o200000 * i64::from(r.remainder))
                                                / i64::from(mag))
                                                as i32;
                                        }
                                        Err(_) => arith_error = true,
                                    }
                                    self.cur_val += f / 0o200000;
                                    f %= 0o200000;
                                }
                            }
                            if self.scan_keyword("pt") {
                                break 'attach_fraction;
                            }
                            let (num, denom): (i32, i32) = if self.scan_keyword("in") {
                                (7227, 100)
                            } else if self.scan_keyword("pc") {
                                (12, 1)
                            } else if self.scan_keyword("cm") {
                                (7227, 254)
                            } else if self.scan_keyword("mm") {
                                (7227, 2540)
                            } else if self.scan_keyword("bp") {
                                (7227, 7200)
                            } else if self.scan_keyword("dd") {
                                (1238, 1157)
                            } else if self.scan_keyword("cc") {
                                (14856, 1157)
                            } else if self.scan_keyword("nd") {
                                (685, 642)
                            } else if self.scan_keyword("nc") {
                                (1370, 107)
                            } else if self.scan_keyword("sp") {
                                break 'done;
                            } else {
                                self.print_err("Illegal unit of measure (");
                                self.printer.print_str("pt inserted)");
                                self.help(&[
                                    "Dimensions can be in units of em, ex, in, pt, pc,",
                                    "cm, mm, dd, cc, nd, nc, bp, or sp; but yours is a new one!",
                                    "I'll assume that you meant to say pt, for printer's points.",
                                    "To recover gracefully from this error, it's best to",
                                    "delete the erroneous units; e.g., type `2' to delete",
                                    "two letters. (See Chapter 27 of The TeXbook.)",
                                ]);
                                self.error();
                                break 'attach_fraction;
                            };
                            match arith::xn_over_d(self.cur_val, num, denom) {
                                Ok(r) => {
                                    self.cur_val = r.quotient;
                                    f = ((i64::from(num) * i64::from(f)
                                        + 0o200000 * i64::from(r.remainder))
                                        / i64::from(denom))
                                        as i32;
                                }
                                Err(_) => arith_error = true,
                            }
                            self.cur_val = self.cur_val.wrapping_add(f / 0o200000);
                            f %= 0o200000;
                            break 'attach_fraction;
                        }
                    } else {
                        if mu {
                            self.scan_something_internal(ValLevel::Mu, false);
                            if self.cur_val_level >= ValLevel::Glue {
                                self.cur_val = self.cur_glue.width;
                            }
                            if self.cur_val_level != ValLevel::Mu {
                                self.mu_error();
                            }
                        } else {
                            self.scan_something_internal(ValLevel::Dimen, false);
                        }
                        v = self.cur_val;
                    }
                    // found:
                    let frac = arith::xn_over_d(v, f, 0o200000)
                        .map(|r| r.quotient)
                        .unwrap_or_else(|_| {
                            arith_error = true;
                            0
                        });
                    self.cur_val = arith::nx_plus_y(save_cur_val, v, frac).unwrap_or_else(|_| {
                        arith_error = true;
                        0
                    });
                    break 'attach_sign;
                }
                // done: (sp units)
                self.scan_optional_space();
                break 'attach_sign;
            }
            // attach_fraction:
            if self.cur_val >= 0o40000 {
                arith_error = true;
            } else {
                self.cur_val = self.cur_val * UNITY + f;
            }
            self.scan_optional_space();
        }
        // attach_sign:
        if arith_error || self.cur_val.wrapping_abs() >= 0o10000000000 || self.cur_val == i32::MIN {
            self.print_err("Dimension too large");
            self.help(&[
                "I can't work with sizes bigger than about 19 feet.",
                "Continue and I'll use the largest value I can.",
            ]);
            self.error();
            self.cur_val = MAX_DIMEN;
        }
        if negative {
            self.cur_val = -self.cur_val;
        }
        cur_order
    }

    /// `scan_int` that also reports whether the radix was 10 (needed by
    /// `scan_dimen` to decide on a decimal fraction).
    fn scan_int_radix(&mut self, radix10: &mut bool) {
        // Peek at the first significant token to learn the radix.
        self.get_nonblank_noncall();
        let t = self.cur_tok;
        *radix10 = !(t == Token::other('\'' as u32)
            || t == Token::other('"' as u32)
            || t == Token::other('`' as u32)
            || self.cur_cmd.is_internal());
        self.back_input();
        self.scan_int();
    }

    /// Freezes the magnification (`prepare_mag`).
    pub fn prepare_mag(&mut self) {
        let mag = self.eqtb.int(pg::assign_int::MAG);
        if self.mag_set > 0 && mag != self.mag_set {
            self.print_err("Incompatible magnification (");
            self.printer.print_int(mag.into());
            self.printer.print_str(");");
            self.printer
                .print_nl(" the previous value will be retained");
            self.help(&[
                "I can handle only one magnification ratio per job. So I've",
                "reverted to the magnification you used earlier on this run.",
            ]);
            self.int_error(self.mag_set);
            self.eqtb.int_par[pg::assign_int::MAG as usize].val = self.mag_set;
        }
        let mag = self.eqtb.int(pg::assign_int::MAG);
        if mag <= 0 || mag > 32768 {
            self.print_err("Illegal magnification has been changed to 1000");
            self.help(&["The magnification ratio must be between 1 and 32768."]);
            self.int_error(mag);
            self.eqtb.int_par[pg::assign_int::MAG as usize].val = 1000;
        }
        self.mag_set = self.eqtb.int(pg::assign_int::MAG);
    }

    /// Reports an error with an integer in parentheses (`int_error`).
    pub fn int_error(&mut self, n: i32) {
        self.printer.print_str(" (");
        self.printer.print_int(n.into());
        self.printer.print_char(')' as u32);
        self.error();
    }

    // ----- glue --------------------------------------------------------------

    /// Scans glue (`scan_glue`); `level` is [`ValLevel::Glue`] or
    /// [`ValLevel::Mu`]. Sets `cur_glue`.
    pub fn scan_glue(&mut self, level: ValLevel) {
        let mu = level == ValLevel::Mu;
        let mut negative = false;
        loop {
            self.get_nonblank_noncall();
            if self.cur_tok == Token::other('-' as u32) {
                negative = !negative;
                self.cur_tok = Token::other('+' as u32);
            }
            if self.cur_tok != Token::other('+' as u32) {
                break;
            }
        }
        if self.cur_cmd.is_internal() {
            self.scan_something_internal(level, negative);
            if self.cur_val_level >= ValLevel::Glue {
                if self.cur_val_level != level {
                    self.mu_error();
                }
                return;
            }
            if self.cur_val_level == ValLevel::Int {
                self.scan_dimen(mu, false, true);
            } else if level == ValLevel::Mu {
                self.mu_error();
            }
        } else {
            self.back_input();
            self.scan_dimen(mu, false, false);
            if negative {
                self.cur_val = -self.cur_val;
            }
        }
        let mut q = Glue::fixed(self.cur_val);
        if self.scan_keyword("plus") {
            let o = self.scan_dimen(mu, true, false);
            q.stretch = self.cur_val;
            q.stretch_order = o;
        }
        if self.scan_keyword("minus") {
            let o = self.scan_dimen(mu, true, false);
            q.shrink = self.cur_val;
            q.shrink_order = o;
        }
        self.cur_glue = q;
        self.cur_val_level = level;
    }

    // ----- internal quantities -----------------------------------------------

    /// Sets the scanned result.
    fn scanned(&mut self, v: i32, level: ValLevel) {
        self.cur_val = v;
        self.cur_val_level = level;
    }

    fn scanned_glue(&mut self, g: Glue, level: ValLevel) {
        self.cur_glue = g;
        self.cur_val = g.width;
        self.cur_val_level = level;
    }

    /// Fetches an internal quantity (`scan_something_internal`, §413).
    pub fn scan_something_internal(&mut self, level: ValLevel, negative: bool) {
        let m = self.cur_chr;
        match self.cur_cmd {
            Cmd::DefCharCode => {
                self.scan_char_num();
                let c = self.cur_val as u32;
                use pg::def_char_code as dc;
                let v = match m {
                    dc::CATCODE => i64::from(self.eqtb.catcode(c)),
                    dc::LCCODE => self.eqtb.lc.get(c),
                    dc::UCCODE => self.eqtb.uc.get(c),
                    dc::SFCODE => self.eqtb.sf.get(c),
                    _ => i64::from(crate::codes::math_code_report(self.eqtb.math.get(c))),
                };
                self.scanned(v as i32, ValLevel::Int);
            }
            Cmd::DefDelCode | Cmd::ExtdefDelCode => {
                self.scan_char_num();
                let v = self.eqtb.del.get(self.cur_val as u32);
                self.scanned(crate::codes::delcode_report(v, self.cur_cmd), ValLevel::Int);
            }
            Cmd::ExtdefMathCode => {
                self.scan_char_num();
                let v = self.eqtb.math.get(self.cur_val as u32);
                self.scanned(crate::codes::math_code_report(v), ValLevel::Int);
            }
            Cmd::ToksRegister | Cmd::AssignToks | Cmd::DefFamily | Cmd::SetFont | Cmd::DefFont => {
                if level != ValLevel::Tok {
                    self.missing_number();
                    self.scanned(0, ValLevel::Dimen);
                } else if self.cur_cmd <= Cmd::AssignToks {
                    let list = if self.cur_cmd == Cmd::ToksRegister {
                        if m == 0 {
                            self.scan_register_num();
                            self.eqtb.toks[self.cur_val as usize].val.clone()
                        } else {
                            self.eqtb.toks[(m - REG_OFFSET) as usize].val.clone()
                        }
                    } else if m >= REG_OFFSET {
                        self.eqtb.toks[(m - REG_OFFSET) as usize].val.clone()
                    } else {
                        self.eqtb.toks_param(m).clone()
                    };
                    self.cur_toks = Some(list);
                    self.cur_val_level = ValLevel::Tok;
                } else {
                    self.back_input();
                    self.scan_font_ident();
                    self.cur_val_level = ValLevel::Ident;
                }
            }
            Cmd::AssignInt => {
                let v = if m >= REG_OFFSET {
                    self.eqtb.count[(m - REG_OFFSET) as usize].val
                } else {
                    self.eqtb.int(m)
                };
                self.scanned(v, ValLevel::Int);
            }
            Cmd::AssignAttr => {
                let v = self.eqtb.attr[(m - REG_OFFSET.min(m)) as usize].val;
                self.scanned(v, ValLevel::Int);
            }
            Cmd::AssignDir | Cmd::AssignDirection => {
                let v = self.eqtb.int(pg::assign_int::COUNT.min(m + DIR_PAR_BASE));
                let _ = v;
                self.scanned(self.dir_param(m), ValLevel::Int);
            }
            Cmd::AssignDimen => {
                let v = if m >= REG_OFFSET {
                    self.eqtb.dimen[(m - REG_OFFSET) as usize].val
                } else {
                    self.eqtb.dimen(m)
                };
                self.scanned(v, ValLevel::Dimen);
            }
            Cmd::AssignGlue => {
                let g = if m >= REG_OFFSET {
                    self.eqtb.skip[(m - REG_OFFSET) as usize].val
                } else {
                    self.eqtb.glue(m)
                };
                self.scanned_glue(g, ValLevel::Glue);
            }
            Cmd::AssignMuGlue => {
                let g = if m >= REG_OFFSET {
                    self.eqtb.muskip[(m - REG_OFFSET) as usize].val
                } else {
                    self.eqtb.glue(m + crate::eqtb::MU_GLUE_OFFSET)
                };
                self.scanned_glue(g, ValLevel::Mu);
            }
            Cmd::SetAux => {
                let v = self.fetch_aux(m);
                if let Some((v, l)) = v {
                    self.scanned(v, l);
                } else {
                    self.scanned(
                        0,
                        if m == SET_AUX_PREV_DEPTH {
                            ValLevel::Dimen
                        } else {
                            ValLevel::Int
                        },
                    );
                }
            }
            Cmd::SetPrevGraf => {
                let v = self.fetch_prev_graf();
                self.scanned(v, ValLevel::Int);
            }
            Cmd::SetPageInt => {
                let v = match m {
                    0 => self.dead_cycles,
                    1 => self.insert_penalties,
                    _ => self.err.interaction as i32,
                };
                self.scanned(v, ValLevel::Int);
            }
            Cmd::SetPageDimen => {
                let v = self.page_so_far_value(m);
                self.scanned(v, ValLevel::Dimen);
            }
            Cmd::SetTexShape => {
                let v = self
                    .eqtb
                    .par_shape
                    .val
                    .as_ref()
                    .map_or(0, |s| (s.len() / 2) as i32);
                self.scanned(v, ValLevel::Int);
            }
            Cmd::SetEtexShape => {
                self.scan_int();
                let n = self.cur_val;
                let v = match &self.eqtb.etex_shape[m as usize].val {
                    None => 0,
                    Some(s) if n < 0 => 0,
                    Some(s) => {
                        let len = s.len() as i32;
                        if n == 0 {
                            len
                        } else {
                            s[(n.min(len) - 1) as usize]
                        }
                    }
                };
                self.scanned(v, ValLevel::Int);
            }
            Cmd::SetBoxDimen => {
                self.scan_register_num();
                let p = self.eqtb.boxes[self.cur_val as usize].val;
                let v = if p.is_null() {
                    0
                } else {
                    let b = self.nodes.box_data(p);
                    match (m, b) {
                        (2, Some(b)) => b.width,
                        (3, Some(b)) => b.depth,
                        (4, Some(b)) => b.height,
                        _ => 0,
                    }
                };
                self.scanned(v, ValLevel::Dimen);
            }
            Cmd::CharGiven | Cmd::XmathGiven => {
                self.scanned(self.cur_chr as i32, ValLevel::Int);
            }
            Cmd::MathGiven => {
                self.scanned(crate::codes::math_given_report(self.cur_chr), ValLevel::Int);
            }
            Cmd::AssignFontDimen => {
                let v = self.find_font_dimen(false);
                self.scanned(v, ValLevel::Dimen);
            }
            Cmd::AssignFontInt => {
                self.scan_font_ident();
                let f = self.cur_val as u32;
                let v = self.font_int_param(f, m);
                self.scanned(v, ValLevel::Int);
            }
            Cmd::Register => {
                self.scan_register_num();
                let n = self.cur_val as usize;
                match m {
                    reg::COUNT => self.scanned(self.eqtb.count[n].val, ValLevel::Int),
                    reg::ATTRIBUTE => self.scanned(self.eqtb.attr[n].val, ValLevel::Int),
                    reg::DIMEN => self.scanned(self.eqtb.dimen[n].val, ValLevel::Dimen),
                    reg::SKIP => {
                        let g = self.eqtb.skip[n].val;
                        self.scanned_glue(g, ValLevel::Glue);
                    }
                    _ => {
                        let g = self.eqtb.muskip[n].val;
                        self.scanned_glue(g, ValLevel::Mu);
                    }
                }
            }
            Cmd::SetMathParam => {
                // After a missing style LuaTeX reads an unset parameter.
                let found = self.scan_math_style();
                let style = self.cur_val as u32;
                let v = self
                    .eqtb
                    .math_param
                    .get(&(m * 8 + style))
                    .filter(|_| found)
                    .map_or(crate::codes::UNDEFINED_MATH_PARAM, |s| s.val);
                if crate::codes::math_param_is_glue(m) {
                    // An unset spacing shows TeX's default for the pair.
                    let g = if found && v == crate::codes::UNDEFINED_MATH_PARAM {
                        let (l, r) = ((m - 49) / 8, (m - 49) % 8);
                        self.math_spacing(l, r, style)
                            .map_or(crate::glue::Glue::ZERO, |(g, _)| g)
                    } else {
                        self.math_param_glue(v)
                    };
                    self.scanned_glue(g, ValLevel::Mu);
                } else if m == crate::mathparams::mp::RADICAL_DEGREE_RAISE {
                    // A percentage.
                    self.scanned(v, ValLevel::Int);
                } else {
                    self.scanned(v, ValLevel::Dimen);
                }
            }
            Cmd::LastItem => self.fetch_last_item(m, level),
            _ => {
                self.print_err("You can't use `");
                self.print_cmd_chr(self.cur_cmd, self.cur_chr);
                self.printer.print_str("' after ");
                self.print_esc_str("the");
                self.help(&["I'm forgetting what you said and using zero instead."]);
                self.error();
                if level != ValLevel::Tok {
                    self.scanned(0, ValLevel::Dimen);
                } else {
                    self.scanned(0, ValLevel::Int);
                }
            }
        }
        // Convert to a lower level.
        while self.cur_val_level > level {
            if self.cur_val_level == ValLevel::Glue {
                self.cur_val = self.cur_glue.width;
            } else if self.cur_val_level == ValLevel::Mu {
                self.mu_error();
            }
            self.cur_val_level = match self.cur_val_level {
                ValLevel::Tok => ValLevel::Ident,
                ValLevel::Ident => ValLevel::Mu,
                ValLevel::Mu => ValLevel::Glue,
                ValLevel::Glue => ValLevel::Dimen,
                _ => ValLevel::Int,
            };
            if self.cur_val_level == ValLevel::Glue || self.cur_val_level == ValLevel::Mu {
                // Coming from Ident/Tok (not possible in practice).
            }
        }
        if negative {
            if self.cur_val_level >= ValLevel::Glue {
                let g = &mut self.cur_glue;
                g.width = -g.width;
                g.stretch = -g.stretch;
                g.shrink = -g.shrink;
                self.cur_val = g.width;
            } else {
                self.cur_val = self.cur_val.wrapping_neg();
            }
        }
    }

    /// Fetches a `last_item` quantity.
    fn fetch_last_item(&mut self, m: u32, level: ValLevel) {
        use last_item as li;
        match m {
            li::LAST_PENALTY | li::LAST_KERN | li::LAST_SKIP | li::LAST_NODE_TYPE => {
                let (v, g, l) = self.fetch_last_node_item(m);
                if l >= ValLevel::Glue {
                    self.scanned_glue(g, l);
                } else {
                    self.scanned(v, l);
                }
            }
            li::INPUT_LINE_NO => self.scanned(self.input.line(), ValLevel::Int),
            li::BADNESS => self.scanned(self.last_badness, ValLevel::Int),
            li::LUATEX_VERSION => self.scanned(LUATEX_VERSION, ValLevel::Int),
            li::ETEX_VERSION => self.scanned(ETEX_VERSION, ValLevel::Int),
            li::ETEX_MINOR_VERSION => self.scanned(ETEX_MINOR_VERSION, ValLevel::Int),
            li::CURRENT_GROUP_LEVEL => {
                self.scanned(i32::from(self.save.cur_level) - 1, ValLevel::Int)
            }
            li::CURRENT_GROUP_TYPE => self.scanned(self.save.cur_group as i32, ValLevel::Int),
            li::CURRENT_IF_LEVEL => self.scanned(self.cond.stack.len() as i32, ValLevel::Int),
            li::CURRENT_IF_TYPE => {
                let v = if self.cond.stack.is_empty() {
                    0
                } else if self.cond.cur_if < crate::cond::UNLESS_CODE {
                    self.cond.cur_if as i32 + 1
                } else {
                    -((self.cond.cur_if - crate::cond::UNLESS_CODE) as i32 + 1)
                };
                self.scanned(v, ValLevel::Int);
            }
            li::CURRENT_IF_BRANCH => {
                let v = match self.cond.if_limit {
                    crate::cond::OR_CODE | crate::cond::ELSE_CODE => 1,
                    crate::cond::FI_CODE => -1,
                    _ => 0,
                };
                self.scanned(v, ValLevel::Int);
            }
            li::RANDOM_SEED => self.scanned(self.random_seed, ValLevel::Int),
            li::LAST_X_POS => self.scanned(self.last_x_pos, ValLevel::Int),
            li::LAST_Y_POS => self.scanned(self.last_y_pos, ValLevel::Int),
            li::LAST_SAVED_BOX_RESOURCE_INDEX
            | li::LAST_SAVED_IMAGE_RESOURCE_INDEX
            | li::LAST_SAVED_IMAGE_RESOURCE_PAGES => {
                self.scanned(self.last_saved_resource(m), ValLevel::Int)
            }
            li::GLUE_STRETCH_ORDER
            | li::GLUE_SHRINK_ORDER
            | li::ETEX_GLUE_STRETCH_ORDER
            | li::ETEX_GLUE_SHRINK_ORDER => {
                self.scan_normal_glue();
                let g = self.cur_glue;
                let o = if m == li::GLUE_STRETCH_ORDER || m == li::ETEX_GLUE_STRETCH_ORDER {
                    g.stretch_order
                } else {
                    g.shrink_order
                };
                // e-TeX reports fil=1…filll=3, LuaTeX's own variant counts
                // the extra `fi` order.
                let v = if m == li::ETEX_GLUE_STRETCH_ORDER || m == li::ETEX_GLUE_SHRINK_ORDER {
                    i32::from(o)
                } else {
                    i32::from(o.saturating_sub(1)).max(0)
                };
                self.scanned(v, ValLevel::Int);
            }
            li::FONT_CHAR_WD | li::FONT_CHAR_HT | li::FONT_CHAR_DP | li::FONT_CHAR_IC => {
                self.scan_font_ident();
                let f = self.cur_val as u32;
                self.scan_char_num();
                let v = self.font_char_dimen(f, self.cur_val as u32, m - li::FONT_CHAR_WD);
                self.scanned(v, ValLevel::Dimen);
            }
            li::PAR_SHAPE_LENGTH | li::PAR_SHAPE_INDENT | li::PAR_SHAPE_DIMEN => {
                let q = m - li::PAR_SHAPE_LENGTH;
                self.scan_int();
                let v = match &self.eqtb.par_shape.val {
                    None => 0,
                    Some(s) if self.cur_val <= 0 => {
                        let _ = s;
                        0
                    }
                    Some(s) => {
                        let n = (s.len() / 2) as i32;
                        let mut cv = self.cur_val;
                        let mut q = q;
                        if q == 2 {
                            q = (cv % 2) as u32;
                            cv = (cv + q as i32) / 2;
                        }
                        if cv > n {
                            cv = n;
                        }
                        // indent is at 2*(k-1), length at 2*(k-1)+1
                        let idx = 2 * (cv - 1) as usize + if q == 0 { 1 } else { 0 };
                        s[idx]
                    }
                };
                self.scanned(v, ValLevel::Dimen);
            }
            li::GLUE_STRETCH | li::GLUE_SHRINK => {
                self.scan_normal_glue();
                let g = self.cur_glue;
                self.scanned(
                    if m == li::GLUE_STRETCH {
                        g.stretch
                    } else {
                        g.shrink
                    },
                    ValLevel::Dimen,
                );
            }
            li::MU_TO_GLUE => {
                self.scan_mu_glue();
                let g = self.cur_glue;
                self.scanned_glue(g, ValLevel::Glue);
            }
            li::GLUE_TO_MU => {
                self.scan_normal_glue();
                let g = self.cur_glue;
                self.scanned_glue(g, ValLevel::Mu);
            }
            li::NUM_EXPR | li::DIM_EXPR | li::GLUE_EXPR | li::MU_EXPR => {
                let l = match m {
                    li::NUM_EXPR => ValLevel::Int,
                    li::DIM_EXPR => ValLevel::Dimen,
                    li::GLUE_EXPR => ValLevel::Glue,
                    _ => ValLevel::Mu,
                };
                self.scan_expr(l);
            }
            _ => {
                let _ = level;
                self.scanned(0, ValLevel::Int);
            }
        }
    }

    /// Scans glue (`scan_normal_glue`).
    pub fn scan_normal_glue(&mut self) {
        self.scan_glue(ValLevel::Glue);
    }

    /// Scans muglue (`scan_mu_glue`).
    pub fn scan_mu_glue(&mut self) {
        self.scan_glue(ValLevel::Mu);
    }

    /// Scans the math style of a `\Umath…` parameter: a style command
    /// (`\displaystyle`, `\crampedtextstyle`, …), whose number (0–7) is
    /// left in `cur_val`. Anything else is put back and reported, and
    /// `\displaystyle` is used (as LuaTeX 1.22 does; numbers are not
    /// accepted). Returns whether a style was found.
    pub fn scan_math_style(&mut self) -> bool {
        self.get_nonblank_noncall();
        if self.cur_cmd == Cmd::MathStyle {
            self.cur_val = self.cur_chr as i32;
            return true;
        }
        self.print_err("Missing math style, treated as ");
        self.print_esc_str("displaystyle");
        self.help(&["A style should have been here; I inserted `\\displaystyle'."]);
        self.back_error();
        self.cur_val = 0;
        false
    }

    // ----- e-TeX expressions -------------------------------------------------

    /// Evaluates an e-TeX expression (`scan_expr`). Sets `cur_val` (or
    /// `cur_glue`) and `cur_val_level`.
    pub fn scan_expr(&mut self, level: ValLevel) {
        let mut arith_err = false;
        let r = self.scan_expr_level(level, &mut arith_err, 0);
        if arith_err {
            self.print_err("Arithmetic overflow");
            self.help(&[
                "I can't evaluate this expression,",
                "since the result is out of range.",
            ]);
            self.error();
            match level {
                ValLevel::Glue | ValLevel::Mu => {
                    self.cur_glue = Glue::ZERO;
                    self.cur_val = 0;
                }
                _ => self.cur_val = 0,
            }
        } else {
            match level {
                ValLevel::Glue | ValLevel::Mu => {
                    self.cur_glue = r;
                    self.cur_val = r.width;
                }
                _ => self.cur_val = r.width,
            }
        }
        self.cur_val_level = level;
    }

    /// Recursive-descent evaluator for e-TeX expressions. Values are
    /// carried as [`Glue`]; integers and dimensions use only `width`.
    fn scan_expr_level(&mut self, l: ValLevel, err: &mut bool, depth: u32) -> Glue {
        // expr ::= term { (+|-) term } ; term ::= factor { (*|/) number }
        let max = |l: ValLevel| {
            if l == ValLevel::Int {
                arith::INFINITY
            } else {
                MAX_DIMEN
            }
        };
        let mut e = Glue::ZERO;
        let mut first = true;
        let mut negative_next = false;
        loop {
            // A term. As in etex.ch, each operator token is read once: the
            // token after a term is the next operator (a back_input there
            // would change the error context of the expression's end).
            let mut t = self.scan_expr_factor(l, err, depth);
            self.get_nonblank_noncall();
            loop {
                if self.cur_tok == Token::other('*' as u32) {
                    self.scan_int_factor(err, depth);
                    let f = self.cur_val;
                    // A following '/' combines into scaling.
                    self.get_nonblank_noncall();
                    if self.cur_tok == Token::other('/' as u32) {
                        self.scan_int_factor(err, depth);
                        let d = self.cur_val;
                        t = self.expr_scale(t, f, d, l, err);
                        self.get_nonblank_noncall();
                    } else {
                        t = self.expr_mult(t, f, l, err);
                    }
                } else if self.cur_tok == Token::other('/' as u32) {
                    self.scan_int_factor(err, depth);
                    let d = self.cur_val;
                    t = self.expr_div(t, d, l, err);
                    self.get_nonblank_noncall();
                } else {
                    break;
                }
            }
            if first {
                e = t;
                first = false;
            } else {
                e = self.expr_add(e, t, l, negative_next, max(l), err);
            }
            if self.cur_tok == Token::other('+' as u32) {
                negative_next = false;
            } else if self.cur_tok == Token::other('-' as u32) {
                negative_next = true;
            } else {
                // End of expression: an optional \relax is absorbed, but
                // only at the outer level (etex.ch: inside parentheses it
                // is the token that is missing a `)`).
                if self.cur_cmd != Cmd::Relax || depth > 0 {
                    self.back_input();
                }
                return e;
            }
        }
    }

    fn scan_expr_factor(&mut self, l: ValLevel, err: &mut bool, depth: u32) -> Glue {
        self.get_nonblank_noncall();
        if self.cur_tok == Token::other('(' as u32) {
            let v = self.scan_expr_paren(l, err, depth);
            return v;
        }
        self.back_input();
        match l {
            ValLevel::Int => {
                self.scan_int();
                Glue::fixed(self.cur_val)
            }
            ValLevel::Dimen => {
                self.scan_normal_dimen();
                Glue::fixed(self.cur_val)
            }
            ValLevel::Glue => {
                self.scan_normal_glue();
                self.cur_glue
            }
            _ => {
                self.scan_mu_glue();
                self.cur_glue
            }
        }
    }

    fn scan_expr_paren(&mut self, l: ValLevel, err: &mut bool, depth: u32) -> Glue {
        let v = self.scan_expr_level(l, err, depth + 1);
        // scan_expr_level stops at a token it backed up; expect ')'.
        self.get_nonblank_noncall();
        if self.cur_tok != Token::other(')' as u32) {
            self.print_err("Missing ) inserted for expression");
            self.help(&["I was expecting to see `+', `-', `*', `/', or `)'. Didn't."]);
            self.back_error();
        }
        v
    }

    fn scan_int_factor(&mut self, err: &mut bool, depth: u32) {
        self.get_nonblank_noncall();
        if self.cur_tok == Token::other('(' as u32) {
            let v = self.scan_expr_paren(ValLevel::Int, err, depth);
            self.cur_val = v.width;
        } else {
            self.back_input();
            self.scan_int();
        }
    }

    fn expr_add(
        &mut self,
        a: Glue,
        b: Glue,
        l: ValLevel,
        neg: bool,
        max: i32,
        err: &mut bool,
    ) -> Glue {
        let mut add = |x: i32, y: i32| match arith::add_or_sub(x, y, max, neg) {
            Ok(v) => v,
            Err(_) => {
                *err = true;
                0
            }
        };
        if l <= ValLevel::Dimen {
            return Glue::fixed(add(a.width, b.width));
        }
        let mut e = a;
        e.width = add(a.width, b.width);
        if e.stretch_order == b.stretch_order {
            e.stretch = add(e.stretch, b.stretch);
        } else if e.stretch_order < b.stretch_order && b.stretch != 0 {
            e.stretch = if neg { -b.stretch } else { b.stretch };
            e.stretch_order = b.stretch_order;
        }
        if e.shrink_order == b.shrink_order {
            e.shrink = add(e.shrink, b.shrink);
        } else if e.shrink_order < b.shrink_order && b.shrink != 0 {
            e.shrink = if neg { -b.shrink } else { b.shrink };
            e.shrink_order = b.shrink_order;
        }
        normalize_glue(e)
    }

    fn expr_mult(&mut self, t: Glue, f: i32, l: ValLevel, err: &mut bool) -> Glue {
        let mut m = |x: i32| {
            let r = if l == ValLevel::Int {
                arith::mult_integers(x, f)
            } else {
                arith::nx_plus_y(x, f, 0)
            };
            r.unwrap_or_else(|_| {
                *err = true;
                0
            })
        };
        if l <= ValLevel::Dimen {
            return Glue::fixed(m(t.width));
        }
        let mut g = t;
        g.width = m(g.width);
        g.stretch = m(g.stretch);
        g.shrink = m(g.shrink);
        normalize_glue(g)
    }

    fn expr_div(&mut self, t: Glue, f: i32, l: ValLevel, err: &mut bool) -> Glue {
        let mut d = |x: i32| {
            arith::quotient(x, f).unwrap_or_else(|_| {
                *err = true;
                0
            })
        };
        if l <= ValLevel::Dimen {
            return Glue::fixed(d(t.width));
        }
        let mut g = t;
        g.width = d(g.width);
        g.stretch = d(g.stretch);
        g.shrink = d(g.shrink);
        normalize_glue(g)
    }

    fn expr_scale(&mut self, t: Glue, n: i32, f: i32, l: ValLevel, err: &mut bool) -> Glue {
        let max = if l == ValLevel::Int {
            arith::INFINITY
        } else {
            MAX_DIMEN
        };
        let mut s = |x: i32| {
            arith::fract(x, n, f, max).unwrap_or_else(|_| {
                *err = true;
                0
            })
        };
        if l <= ValLevel::Dimen {
            return Glue::fixed(s(t.width));
        }
        let mut g = t;
        g.width = s(g.width);
        g.stretch = s(g.stretch);
        g.shrink = s(g.shrink);
        normalize_glue(g)
    }

    // ----- token lists -------------------------------------------------------

    /// Part of [`scan_toks`](Self::scan_toks): appends to `out` the tokens
    /// of the current token list that `scan_toks` would copy unchanged
    /// (characters other than `#`, `&` and parameters; braces, counted in
    /// `unbalance`; control sequences that are not expandable, or protected
    /// macros, when expanding; any but outer ones when not), and stops at
    /// the first other token, which the general path handles. Returns the
    /// closing brace if the list ended the body.
    fn copy_plain_tokens(
        &mut self,
        out: &mut Vec<Token>,
        unbalance: &mut i32,
        xpand: bool,
    ) -> Option<Token> {
        let Some(crate::input::Level::Tokens(t)) = self.input.stack.last_mut() else {
            return None;
        };
        while let Some(&tok) = t.list.get(t.loc) {
            if tok.is_cs() {
                let m = self.eqtb.meaning(tok.cs_id());
                let plain = if m.cmd <= Cmd::MAX_COMMAND {
                    !(Cmd::TabMark..=Cmd::CarRet).contains(&m.cmd)
                } else if m.cmd.is_outer_or_special() {
                    false
                } else if xpand {
                    m.cmd >= Cmd::Call && m.mac.as_ref().is_some_and(|m| m.protected)
                } else {
                    true
                };
                if !plain {
                    return None;
                }
            } else {
                match tok.cmd() {
                    Cmd::LeftBrace => {
                        self.input.align_state += 1;
                        *unbalance += 1;
                    }
                    Cmd::RightBrace => {
                        self.input.align_state -= 1;
                        *unbalance -= 1;
                        if *unbalance == 0 {
                            t.loc += 1;
                            return Some(tok);
                        }
                    }
                    Cmd::TabMark | Cmd::CarRet | Cmd::MacParam => return None,
                    _ => {}
                }
            }
            out.push(tok);
            t.loc += 1;
        }
        None
    }

    /// Scans a balanced text (`scan_toks`). For macro definitions
    /// (`macro_def`), the parameter text is scanned first and the result
    /// contains match tokens, `END_MATCH` and the body. With `xpand`, the
    /// text is expanded as in `\edef`. Returns the list and whether the
    /// definition text used `#` correctly.
    pub fn scan_toks(&mut self, macro_def: bool, xpand: bool) -> Vec<Token> {
        if macro_def {
            self.input.scanner_status = ScannerStatus::Defining;
        } else {
            self.input.scanner_status = ScannerStatus::Absorbing;
        }
        self.input.warning_index = self.cur_cs;
        let mut out: Vec<Token> = Vec::new();
        // The tokens scanned so far are shown if the text runs away; they
        // stay in `runaway_list` while more input is read.
        let saved_runaway = std::mem::take(&mut self.runaway_list);
        macro_rules! runaway {
            ($e:expr) => {{
                self.runaway_list = std::mem::take(&mut out);
                let r = $e;
                out = std::mem::take(&mut self.runaway_list);
                r
            }};
        }
        let mut unbalance: i32;
        let mut t: u32 = 0x30; // zero_token: next parameter number
        let mut hash_brace = Token(0);
        'found: {
            if macro_def {
                // Scan and build the parameter part; `#{` ends it early
                // (§476) and the body follows.
                'params: loop {
                    runaway!(self.get_token());
                    if self.cur_tok.0 < Token::RIGHT_BRACE.0 & !0x1F_FFFF | 0x1F_FFFF
                        && !self.cur_tok.is_cs()
                        && self.cur_cmd <= Cmd::RightBrace
                    {
                        break; // left or right brace
                    }
                    if self.cur_cmd == Cmd::MacParam && !self.cur_tok.is_cs() {
                        // A parameter, or #{.
                        let s = Token::match_token(self.cur_chr);
                        runaway!(self.get_token());
                        if self.cur_cmd == Cmd::LeftBrace && !self.cur_tok.is_cs() {
                            hash_brace = self.cur_tok;
                            out.push(self.cur_tok);
                            break 'params;
                        }
                        if t == 0x39 {
                            self.print_err("You already have nine parameters");
                            self.help(&["I'm going to ignore the # sign you just used."]);
                            self.error();
                        } else {
                            t += 1;
                            if self.cur_tok != Token::other(t) {
                                self.print_err("Parameters must be numbered consecutively");
                                self.help(&[
                                    "I've inserted the digit you should have used after the #.",
                                    "Type `1' to delete what you did use.",
                                ]);
                                self.back_error();
                            }
                            self.cur_tok = s;
                        }
                    }
                    out.push(self.cur_tok);
                }
                out.push(Token::END_MATCH);
                if hash_brace.0 == 0 && self.cur_cmd == Cmd::RightBrace {
                    self.print_err("Missing { inserted");
                    self.input.align_state += 1;
                    self.help(&[
                        "Where was the left brace? You said something like `\\def\\a}',",
                        "which I'm going to interpret as `\\def\\a{}'.",
                    ]);
                    self.error();
                    break 'found;
                }
            } else {
                self.scan_left_brace();
            }
            // Scan and build the body.
            unbalance = 1;
            loop {
                // Fast path: copy the plain tokens of the current token list
                // directly (most of the body of an \edef that re-expands a
                // long macro).
                if let Some(end_brace) = self.copy_plain_tokens(&mut out, &mut unbalance, xpand) {
                    self.cur_tok = end_brace;
                    self.cur_cmd = Cmd::RightBrace;
                    self.cur_chr = end_brace.chr();
                    self.cur_cs = NO_CS;
                    break 'found;
                }
                if xpand {
                    // Expand the next part of the input.
                    loop {
                        runaway!(self.get_next());
                        if self.cur_cmd >= Cmd::Call
                            && self
                                .eqtb
                                .meaning(self.cur_cs)
                                .mac
                                .as_ref()
                                .is_some_and(|m| m.protected)
                        {
                            self.cur_cmd = Cmd::Relax;
                            self.cur_chr = crate::input::NO_EXPAND_FLAG;
                            break;
                        }
                        if self.cur_cmd <= Cmd::MAX_COMMAND {
                            break;
                        }
                        if self.cur_cmd != Cmd::The {
                            runaway!(self.expand());
                        } else {
                            let list = runaway!(self.the_toks());
                            out.extend_from_slice(&list);
                        }
                    }
                    runaway!(self.x_token());
                } else {
                    runaway!(self.get_token());
                }
                if self.cur_tok.is_cs()
                    || self.cur_cmd > Cmd::MacParam
                    || self.cur_cmd < Cmd::LeftBrace
                {
                    // not a brace or parameter
                } else if self.cur_cmd < Cmd::RightBrace {
                    unbalance += 1;
                } else if self.cur_cmd == Cmd::RightBrace {
                    unbalance -= 1;
                    if unbalance == 0 {
                        break 'found;
                    }
                } else if self.cur_cmd == Cmd::MacParam && macro_def {
                    // Look for parameter number or ##.
                    let s = self.cur_tok;
                    if xpand {
                        runaway!(self.get_x_token());
                    } else {
                        runaway!(self.get_token());
                    }
                    if self.cur_cmd != Cmd::MacParam || self.cur_tok.is_cs() {
                        let c = self.cur_tok;
                        if c.is_cs() || c.cmd() != Cmd::OtherChar || c.chr() <= 0x30 || c.chr() > t
                        {
                            self.print_err("Illegal parameter number in definition of ");
                            self.sprint_cs(self.input.warning_index);
                            self.help(&[
                                "You meant to type ## instead of #, right?",
                                "Or maybe a } was forgotten somewhere earlier, and things",
                                "are all screwed up? I'm going to assume that you meant ##.",
                            ]);
                            self.back_error();
                            self.cur_tok = s;
                        } else {
                            self.cur_tok = Token::out_param(c.chr() - 0x30);
                        }
                    }
                }
                out.push(self.cur_tok);
            }
        }
        self.input.scanner_status = ScannerStatus::Normal;
        self.runaway_list = saved_runaway;
        if hash_brace.0 != 0 {
            out.push(hash_brace);
        }
        out
    }
}

/// Offset used to map direction parameter modifiers (unused placeholder).
const DIR_PAR_BASE: u32 = 0;

/// `set_aux` modifier for `\prevdepth`.
pub const SET_AUX_PREV_DEPTH: u32 = 1;
/// `set_aux` modifier for `\spacefactor`.
pub const SET_AUX_SPACE_FACTOR: u32 = 134;

/// Sets an infinite component's order to normal when the component is
/// zero (`normalize_glue`).
pub fn normalize_glue(mut g: Glue) -> Glue {
    if g.stretch == 0 {
        g.stretch_order = glue::NORMAL;
    }
    if g.shrink == 0 {
        g.shrink_order = glue::NORMAL;
    }
    g
}

/// Avoids an unused-import warning when `Loc` is not needed here.
#[allow(dead_code)]
fn _loc(_: Loc) {}