use super::stomach::CMode;
use super::{Lowerer, R};
use crate::catcode::Cat;
use crate::expand::{GroupKind, Meaning, TexError};
use crate::ir::list::ListOp;
use crate::ir::{Cmd, Num};
use crate::lexer::Lexer;
use crate::token::{CsId, Token};
const END_TEMPLATE: &str = "\u{0}endtemplate";
const U_END: &str = "\u{0}u-template-end";
#[derive(Clone, Debug)]
struct Column {
u: Vec<Token>,
v: Vec<Token>,
}
#[derive(Clone, Debug)]
struct Entry {
u_done: bool,
braces: i64,
omit: bool,
ended: Option<u8>,
in_v: bool,
}
#[derive(Clone, Debug)]
pub(super) struct Align {
halign: bool,
columns: Vec<Column>,
repeat: Option<(usize, usize)>,
cur: usize,
entry: Option<Entry>,
}
impl Lowerer {
fn tabskip_slots(&self) -> [Num; 4] {
let s = crate::params::register_slot("tabskip").unwrap_or(0);
[
Num::Count(s),
Num::Count(s + 1),
Num::Count(s + 2),
Num::Count(s + 3),
]
}
fn st_meaning_of(&self, t: &Token) -> Option<String> {
let Token::Cs(n) = t else {
return None;
};
let p = match self.eng.meanings.get(n) {
Some(Meaning::Primitive(p)) => *p,
Some(_) => return None,
None => *n,
};
Some(p.name().to_string())
}
pub(super) fn st_init_align(
&mut self,
lx: &mut Lexer,
halign: bool,
out: &mut Vec<Cmd>,
) -> R<()> {
let display = self.st_mode() == CMode::DisplayMath;
let (exactly, size) = if self.eng.scan_keyword(lx, "to", false)? {
(true, self.dimen_number(lx, false)?)
} else if self.eng.scan_keyword(lx, "spread", false)? {
(false, self.dimen_number(lx, false)?)
} else {
(false, Num::Literal(0))
};
self.st_emit(
out,
ListOp::InitAlign {
halign,
exactly,
size,
},
)?;
let mode = match halign {
true => CMode::InternalVertical,
false => CMode::RestrictedHorizontal,
};
self.st_push(mode);
self.eng
.compile_time_begin_group(GroupKind::Align, lx.line());
let outer_mark = self.globals.len();
let outer_known = self.eng.known.mark();
let mut outer: Vec<Cmd> = Vec::new();
match self
.st_next_non_blank(lx)?
.map(|(t, p)| (self.st_implicit(t), p))
{
Some((Token::Char(_, Cat::BeginGroup), _)) => {}
other => {
if let Some((t, _)) = other {
lx.push_back(&[t]);
}
self.eng.report(lx, "Missing { inserted");
}
}
self.st.aligns.push(Align {
halign,
columns: Vec::new(),
repeat: None,
cur: 0,
entry: None,
});
self.st_preamble(lx, &mut outer)?;
outer.push(Cmd::List(ListOp::AlignEntries));
let mut entry = self.st_open_entry_group(lx);
self.st_every_cr(lx);
let mut entry_body: Vec<Cmd> = Vec::new();
while let Some(t) = self.st_align_peek(lx, &mut entry_body)? {
self.st_emit(&mut entry_body, ListOp::InitRow)?;
if let Some(a) = self.st.aligns.last_mut() {
a.cur = 0;
}
let mut next = t;
loop {
let ended = self.st_read_entry(lx, next, &mut entry_body)?;
let kind = self.st_end_of_preamble_check(lx, ended, &mut entry_body)?;
if kind == 1 {
self.st_emit(&mut entry_body, ListOp::FinCol(1))?;
} else {
self.st_close_entry_group(entry, &mut entry_body, &mut outer)?;
outer.push(Cmd::List(ListOp::FinCol(kind)));
entry = self.st_open_entry_group(lx);
if kind == 2 {
outer.push(Cmd::List(ListOp::FinRow));
self.st_every_cr(lx);
break;
}
}
if let Some(a) = self.st.aligns.last_mut() {
a.cur += 1;
}
next = self.st_next_non_call(lx)?;
}
}
self.st_close_entry_group(entry, &mut entry_body, &mut outer)?;
self.st.aligns.pop();
self.st_pop();
self.eng.compile_time_end_group()?;
let after = self.eng.take_after_group();
lx.push_back(&after);
let (saves, keeps) = self.group_parts(&mut outer, outer_mark)?;
self.known_after_group(outer_known, &saves, &keeps);
out.push(Cmd::Group {
saves,
keeps,
body: outer,
});
let indent = match display {
true => Num::Count(crate::params::register_slot("displayindent").unwrap_or(0)),
false => Num::Literal(0),
};
self.st_emit(out, ListOp::FinAlign(indent))?;
if display {
self.st_finish_display_alignment(lx, out)?;
}
Ok(())
}
fn st_finish_display_alignment(&mut self, lx: &mut Lexer, out: &mut Vec<Cmd>) -> R<()> {
let mut dollars = 0;
while dollars < 2 {
match self.eng.next_unexpandable(lx)? {
Some((Token::Char(_, Cat::MathShift), _)) => dollars += 1,
Some((t, _)) if t.is_space() && dollars == 0 => {}
other => {
if let Some((t, _)) = other {
lx.back_input(&[t]);
}
let msg = match dollars {
0 => "Missing $$ inserted",
_ => "Display math should end with $$",
};
self.eng.report(lx, msg);
break;
}
}
}
self.st_emit(out, ListOp::FinishDisplayAlignment)?;
self.st.end_block = true;
Ok(())
}
fn st_preamble(&mut self, lx: &mut Lexer, outer: &mut Vec<Cmd>) -> R<()> {
loop {
outer.push(Cmd::List(ListOp::AlignTabskip(self.tabskip_slots())));
let mut u: Vec<Token> = Vec::new();
let mut periodic = false;
loop {
let t = self.st_preamble_token(lx, outer)?;
if matches!(t, Token::Char(_, Cat::Param)) {
break;
}
let m = self.st_meaning_of(&t);
let ends = matches!(t, Token::Char(_, Cat::AlignTab))
|| matches!(m.as_deref(), Some("span" | "cr" | "crcr"));
if ends {
let first = u.is_empty()
&& matches!(t, Token::Char(_, Cat::AlignTab))
&& !self.st.aligns.last().is_some_and(|a| a.repeat.is_some())
&& !periodic;
if first {
periodic = true;
continue;
}
lx.back_input(&[t]);
self.eng
.report(lx, "Missing # inserted in alignment preamble");
break;
}
if !(t.is_space() && u.is_empty()) {
u.push(t);
}
}
if periodic {
let n = self.st.aligns.last().map_or(0, |a| a.columns.len());
if let Some(a) = self.st.aligns.last_mut() {
a.repeat = Some((n, n));
}
}
outer.push(Cmd::List(ListOp::AlignRecord(periodic)));
let mut v: Vec<Token> = Vec::new();
let ender = loop {
let t = self.st_preamble_token(lx, outer)?;
let m = self.st_meaning_of(&t);
if matches!(t, Token::Char(_, Cat::AlignTab))
|| matches!(m.as_deref(), Some("span" | "cr" | "crcr"))
{
break t;
}
if matches!(t, Token::Char(_, Cat::Param)) {
self.eng.report(lx, "Only one # is allowed per tab");
continue;
}
v.push(t);
};
v.push(Token::cs(END_TEMPLATE));
if let Some(a) = self.st.aligns.last_mut() {
a.columns.push(Column { u, v });
}
if matches!(self.st_meaning_of(&ender).as_deref(), Some("cr" | "crcr")) {
outer.push(Cmd::List(ListOp::AlignTabskip(self.tabskip_slots())));
return Ok(());
}
}
}
fn st_preamble_token(&mut self, lx: &mut Lexer, outer: &mut Vec<Cmd>) -> R<Token> {
loop {
let Some(mut t) = lx.next_token(&self.eng.cats) else {
return Err(TexError(
"File ended while scanning preamble of \\halign".into(),
));
};
if let Token::Char(c, Cat::Active) = t {
if let Some(id) = self.eng.active_meaning(c) {
t = Token::Cs(id);
}
}
match self.st_meaning_of(&t).as_deref() {
Some("span") => {
let Some(next) = lx.next_token(&self.eng.cats) else {
continue;
};
if let Token::Cs(n) = next {
if self.eng.expand_once(lx, n)? {
continue;
}
}
lx.push_back(&[next]);
continue;
}
Some("tabskip") => {
let slot = crate::params::register_slot("tabskip").unwrap_or(0);
self.eng.skip_equals_file(lx)?;
let cmds = self.glue_assign(lx, slot)?;
outer.extend(cmds);
continue;
}
_ => {}
}
if matches!(&t, Token::Cs(n) if n.name() == END_TEMPLATE) {
return Err(TexError(
"(interwoven alignment preambles are not allowed)".into(),
));
}
return Ok(t);
}
}
fn st_every_cr(&mut self, lx: &mut Lexer) {
if let Some(toks) =
crate::params::toks_register("everycr").and_then(|r| self.eng.toks.get(&r).cloned())
{
lx.push_back(&toks);
}
}
fn st_open_entry_group(&mut self, lx: &Lexer) -> (usize, usize) {
self.eng
.compile_time_begin_group(GroupKind::Align, lx.line());
(self.globals.len(), self.eng.known.mark())
}
fn st_close_entry_group(
&mut self,
(mark, known): (usize, usize),
body: &mut Vec<Cmd>,
outer: &mut Vec<Cmd>,
) -> R<()> {
self.eng.compile_time_end_group()?;
let mut b = std::mem::take(body);
let (saves, keeps) = self.group_parts(&mut b, mark)?;
self.known_after_group(known, &saves, &keeps);
outer.push(Cmd::Group {
saves,
keeps,
body: b,
});
Ok(())
}
fn st_next_non_call(&mut self, lx: &mut Lexer) -> R<Token> {
loop {
match self.eng.next_unexpandable(lx)? {
Some((t, _)) if t.is_space() => continue,
Some((t, _)) => return Ok(self.st_implicit(t)),
None => return Err(TexError("File ended within an alignment".into())),
}
}
}
fn st_align_peek(&mut self, lx: &mut Lexer, body: &mut Vec<Cmd>) -> R<Option<Token>> {
loop {
let t = self.st_next_non_call(lx)?;
match self.st_meaning_of(&t).as_deref() {
Some("noalign") => {
self.st_noalign(lx, body)?;
continue;
}
Some("crcr") => continue,
_ => {}
}
if matches!(t, Token::Char(_, Cat::EndGroup)) {
return Ok(None);
}
return Ok(Some(t));
}
}
fn st_noalign(&mut self, lx: &mut Lexer, body: &mut Vec<Cmd>) -> R<()> {
match self
.st_next_non_blank(lx)?
.map(|(t, p)| (self.st_implicit(t), p))
{
Some((Token::Char(_, Cat::BeginGroup), _)) => {}
other => {
if let Some((t, _)) = other {
lx.push_back(&[t]);
}
self.eng.report(lx, "Missing { inserted");
}
}
self.eng
.compile_time_begin_group(GroupKind::NoAlign, lx.line());
let mark = self.globals.len();
let known = self.eng.known.mark();
let mut inner = Vec::new();
if self.st.aligns.last().is_some_and(|a| a.halign) {
self.st_normal_paragraph(&mut inner);
}
let saved = self.st.aligns.last_mut().and_then(|a| a.entry.take());
let mut b = self.block(lx, Some(&["\u{0}endgroup"]))?;
if let Some(a) = self.st.aligns.last_mut() {
a.entry = saved;
}
inner.append(&mut b);
if self.st_mode() == CMode::Horizontal {
self.st_end_graf(&mut inner)?;
}
self.eng.compile_time_end_group()?;
self.st_group_body(&mut inner);
let (saves, keeps) = self.group_parts(&mut inner, mark)?;
self.known_after_group(known, &saves, &keeps);
body.push(Cmd::Group {
saves,
keeps,
body: inner,
});
Ok(())
}
fn st_read_entry(&mut self, lx: &mut Lexer, t: Token, body: &mut Vec<Cmd>) -> R<u8> {
let (halign, column) = {
let a = self
.st
.aligns
.last()
.ok_or_else(|| TexError("no alignment".into()))?;
(a.halign, a.columns.get(a.cur).cloned())
};
let omit = matches!(self.st_meaning_of(&t).as_deref(), Some("omit"));
let mode = match halign {
true => CMode::RestrictedHorizontal,
false => CMode::InternalVertical,
};
self.st_push(mode);
let nest_len = self.st.nest.len();
if omit {
} else {
let mut toks = column.as_ref().map(|c| c.u.clone()).unwrap_or_default();
toks.push(Token::cs(U_END));
toks.push(t);
lx.push_back(&toks);
}
if let Some(a) = self.st.aligns.last_mut() {
a.entry = Some(Entry {
u_done: omit,
braces: 0,
omit,
ended: None,
in_v: false,
});
}
self.st.run_open = false;
let mut b = self.block(lx, None)?;
self.st.run_open = false;
body.append(&mut b);
while self.st.nest.len() > nest_len {
self.st_pop();
}
self.st_pop();
let ended = self
.st
.aligns
.last_mut()
.and_then(|a| a.entry.take())
.and_then(|e| e.ended)
.unwrap_or(2);
Ok(ended)
}
fn st_end_of_preamble_check(&mut self, lx: &mut Lexer, kind: u8, body: &mut Vec<Cmd>) -> R<u8> {
if kind == 2 {
return Ok(2);
}
let Some(a) = self.st.aligns.last_mut() else {
return Ok(2);
};
if a.cur + 1 < a.columns.len() {
return Ok(kind);
}
match a.repeat {
Some((start, next)) => {
let col = a.columns[next].clone();
a.columns.push(col);
a.repeat = Some((start, next + 1));
body.push(Cmd::List(ListOp::AlignLengthen));
Ok(kind)
}
None => {
let esc = self.eng.esc().to_string();
self.eng.report(
lx,
&format!("Extra alignment tab has been changed to {esc}cr"),
);
Ok(2)
}
}
}
pub(super) fn st_align_token(
&mut self,
lx: &mut Lexer,
t: &Token,
out: &mut Vec<Cmd>,
) -> R<bool> {
let meaning = self.st_meaning_of(t);
let in_group = self.eng.innermost_group();
let Some(a) = self.st.aligns.last_mut() else {
return Ok(false);
};
let Some(entry) = a.entry.as_mut() else {
return Ok(false);
};
match t {
Token::Cs(n) if n.name() == U_END => {
entry.u_done = true;
entry.braces = 0;
return Ok(true);
}
Token::Cs(n) if n.name() == END_TEMPLATE => {
if !entry.in_v {
return Ok(true);
}
if in_group != Some(GroupKind::Align) {
lx.push_back(&[*t]);
let esc = self.eng.esc().to_string();
let (closer, shown) = match in_group {
Some(GroupKind::SemiSimple) => {
(Token::cs("endgroup"), format!("{esc}endgroup"))
}
Some(GroupKind::MathShift) => {
(Token::Char('$', Cat::MathShift), "$".into())
}
_ => (Token::Char('}', Cat::EndGroup), "}".into()),
};
lx.push_back(&[closer]);
self.eng.report(lx, &format!("Missing {shown} inserted"));
return Ok(true);
}
if self.st_mode() == CMode::Horizontal {
self.st_end_graf(out)?;
}
self.st.end_block = true;
return Ok(true);
}
Token::Char(_, Cat::BeginGroup) if entry.u_done => {
entry.braces += 1;
return Ok(false);
}
Token::Char(_, Cat::EndGroup) if entry.u_done => {
entry.braces -= 1;
return Ok(false);
}
_ => {}
}
let implicit_tab = matches!(t, Token::Cs(n)
if matches!(self.eng.meanings.get(n), Some(Meaning::Char(_, Cat::AlignTab))));
let Some(a) = self.st.aligns.last_mut() else {
return Ok(false);
};
let Some(entry) = a.entry.as_mut() else {
return Ok(false);
};
let kind = match (t, meaning.as_deref()) {
(Token::Char(_, Cat::AlignTab), _) => 0,
_ if implicit_tab => 0,
(_, Some("span")) => 1,
(_, Some("cr" | "crcr")) => 2,
_ => return Ok(false),
};
if !entry.u_done || entry.braces != 0 || entry.in_v {
return Ok(false);
}
entry.ended = Some(kind);
entry.in_v = true;
let omit = entry.omit;
let cur = a.cur;
let v = match omit {
true => vec![Token::cs(END_TEMPLATE)],
false => a.columns.get(cur).map(|c| c.v.clone()).unwrap_or_default(),
};
lx.push_back(&v);
Ok(true)
}
pub(super) fn st_misplaced_align(&mut self, lx: &mut Lexer, name: CsId) -> bool {
let shown = match self.st_meaning_of(&Token::Cs(name)).as_deref() {
Some("cr") => "cr",
Some("crcr") => "crcr",
Some("span") => "span",
Some("noalign") => "noalign",
Some("omit") => "omit",
_ => return false,
};
if matches!(shown, "crcr") && self.st.aligns.is_empty() {
return true;
}
let esc = self.eng.esc().to_string();
self.eng.report(lx, &format!("Misplaced {esc}{shown}"));
true
}
}
impl Lowerer {
pub(super) fn st_in_align_entry(&self) -> bool {
self.st.aligns.last().is_some_and(|a| a.entry.is_some())
}
}
impl Lowerer {
pub(super) fn st_align_brace(&mut self) {
if let Some(e) = self.st.aligns.last_mut().and_then(|a| a.entry.as_mut()) {
if e.u_done {
e.braces += 1;
}
}
}
}
impl Lowerer {
pub(super) fn st_align_unbrace(&mut self) {
if let Some(e) = self.st.aligns.last_mut().and_then(|a| a.entry.as_mut()) {
if e.u_done {
e.braces -= 1;
}
}
}
}