use crate::tables::{entry, EAST_ASIAN, EXTPICT_UNASSIGNED, LB_MASK, LB_SHIFT};
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[repr(u8)]
#[allow(clippy::upper_case_acronyms)]
pub(crate) enum Lb {
XX = 0,
AK,
AL,
AP,
AS,
B2,
BA,
BB,
BK,
CB,
CL,
CM,
CP,
CR,
EB,
EM,
EX,
GL,
H2,
H3,
HH,
HL,
HY,
ID,
IN,
IS,
JL,
JT,
JV,
LF,
NL,
NS,
NU,
OP,
PO,
PR,
QU,
QUPi,
QUPf,
RI,
SP,
SY,
VF,
VI,
WJ,
ZW,
ZWJ,
}
#[rustfmt::skip]
const LB_TABLE: [Lb; 64] = {
use Lb::*;
[
XX, AK, AL, AP, AS, B2, BA, BB, BK, CB, CL, CM, CP, CR, EB, EM, EX, GL,
H2, H3, HH, HL, HY, ID, IN, IS, JL, JT, JV, LF, NL, NS, NU, OP, PO, PR,
QU, QUPi, QUPf, RI, SP, SY, VF, VI, WJ, ZW, ZWJ,
XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX,
]
};
impl Lb {
fn of(c: char) -> Lb {
LB_TABLE[((entry(c as u32) >> LB_SHIFT) & LB_MASK) as usize]
}
fn is_qu(self) -> bool {
matches!(self, Lb::QU | Lb::QUPi | Lb::QUPf)
}
fn is_hard(self) -> bool {
matches!(self, Lb::BK | Lb::CR | Lb::LF | Lb::NL)
}
}
fn east_asian(c: char) -> bool {
entry(c as u32) & EAST_ASIAN != 0
}
fn extpict_unassigned(c: char) -> bool {
entry(c as u32) & EXTPICT_UNASSIGNED != 0
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Break {
Mandatory,
Allowed,
}
#[derive(Clone)]
pub struct LineBreaks<'a> {
s: &'a str,
pos: usize,
seen: usize,
prev: Ch,
prev2: Option<Ch>,
nonsp: Ch,
ctx: Option<Ch>,
spaces: usize,
ri: usize,
num: Num,
prev_zwj: bool,
done: bool,
}
#[derive(Clone, Copy, PartialEq, Eq)]
struct Ch {
class: Lb,
ea: bool,
dotted: bool,
pict: bool,
}
impl Ch {
const NONE: Ch = Ch {
class: Lb::XX,
ea: false,
dotted: false,
pict: false,
};
fn new(c: char, class: Lb) -> Ch {
Ch {
class,
ea: east_asian(c),
dotted: c == '\u{25CC}',
pict: extpict_unassigned(c),
}
}
}
impl<'a> LineBreaks<'a> {
pub(crate) fn new(s: &'a str) -> Self {
LineBreaks {
s,
pos: 0,
seen: 0,
prev: Ch::NONE,
prev2: None,
nonsp: Ch::NONE,
ctx: None,
spaces: 0,
ri: 0,
num: Num::No,
prev_zwj: false,
done: false,
}
}
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Num {
No,
In,
Closed,
}
impl Iterator for LineBreaks<'_> {
type Item = (usize, Break);
fn next(&mut self) -> Option<(usize, Break)> {
loop {
let Some(c) = self.s[self.pos..].chars().next() else {
if self.done {
return None;
}
self.done = true;
return Some((self.s.len(), Break::Mandatory));
};
let at = self.pos;
self.pos += c.len_utf8();
let raw = Lb::of(c);
let attaches = self.seen > 0
&& !(self.prev.class.is_hard() || matches!(self.prev.class, Lb::SP | Lb::ZW));
if matches!(raw, Lb::CM | Lb::ZWJ) && attaches {
self.prev_zwj = raw == Lb::ZWJ;
continue;
}
let resolved = match raw {
Lb::CM | Lb::ZWJ => Lb::AL,
other => other,
};
let ch = Ch::new(c, resolved);
let verdict = if self.seen == 0 {
None
} else {
self.decide(ch, at + c.len_utf8())
};
self.consume(ch, raw == Lb::ZWJ);
if let Some(kind) = verdict {
return Some((at, kind));
}
}
}
}
impl LineBreaks<'_> {
fn consume(&mut self, ch: Ch, was_zwj: bool) {
if ch.class != Lb::SP {
self.ctx = if self.seen == 0 {
None
} else {
Some(self.prev)
};
self.nonsp = ch;
self.spaces = 0;
} else {
self.spaces += 1;
}
self.ri = if ch.class == Lb::RI { self.ri + 1 } else { 0 };
self.num = match (self.num, ch.class) {
(_, Lb::NU) => Num::In,
(Num::In, Lb::SY | Lb::IS) => Num::In,
(Num::In, Lb::CL | Lb::CP) => Num::Closed,
_ => Num::No,
};
self.prev2 = if self.seen == 0 {
None
} else {
Some(self.prev)
};
self.prev = ch;
self.prev_zwj = was_zwj;
self.seen += 1;
}
fn class_at(&self, i: usize) -> Option<Lb> {
self.s[i..].chars().next().map(Lb::of)
}
fn ea_at(&self, i: usize) -> Option<bool> {
self.s[i..].chars().next().map(east_asian)
}
fn decide(&self, cur: Ch, end: usize) -> Option<Break> {
use Lb::*;
let b = self.prev.class;
let a = cur.class;
let nsp = self.nonsp.class;
let brk = Some(Break::Allowed);
let stay = None;
let ak = |c: Ch| matches!(c.class, AK | AS) || c.dotted;
if b == BK {
return Some(Break::Mandatory);
}
if b == CR && a == LF {
return stay;
}
if matches!(b, CR | LF | NL) {
return Some(Break::Mandatory);
}
if a.is_hard() || matches!(a, SP | ZW) {
return stay;
}
if nsp == ZW {
return brk;
}
if self.prev_zwj {
return stay;
}
if a == WJ || b == WJ {
return stay;
}
if b == GL {
return stay;
}
if a == GL && !matches!(b, SP | BA | HY | HH) {
return stay;
}
if matches!(a, CL | CP | EX | SY) {
return stay;
}
if nsp == OP {
return stay;
}
if nsp == QUPi
&& match self.ctx {
None => true,
Some(x) => {
x.class.is_hard() || matches!(x.class, OP | GL | SP | ZW) || x.class.is_qu()
}
}
{
return stay;
}
if a == QUPf {
match self.class_at(end) {
None => return stay,
Some(n)
if n.is_qu()
|| n.is_hard()
|| matches!(n, SP | GL | WJ | CL | CP | EX | IS | SY | ZW) =>
{
return stay
}
_ => {}
}
}
if b == SP && a == IS && self.class_at(end) == Some(NU) {
return brk;
}
if a == IS {
return stay;
}
if matches!(nsp, CL | CP) && a == NS {
return stay;
}
if nsp == B2 && a == B2 {
return stay;
}
if b == SP {
return brk;
}
if matches!(a, QU | QUPf) && !cur.ea {
return stay;
}
if matches!(b, QU | QUPi) && !self.prev.ea {
return stay;
}
if a.is_qu() && (!self.prev.ea || self.ea_at(end) != Some(true)) {
return stay;
}
if b.is_qu() && (!cur.ea || self.prev2.map(|p| p.ea) != Some(true)) {
return stay;
}
if a == CB || b == CB {
return brk;
}
if matches!(a, AL | HL)
&& matches!(b, HY | HH)
&& match self.ctx {
None => true,
Some(x) => x.class.is_hard() || matches!(x.class, SP | ZW | CB | GL),
}
{
return stay;
}
if matches!(a, BA | HH | HY | NS) {
return stay;
}
if b == BB {
return stay;
}
if b == HY && self.ctx.map(|x| x.class) == Some(HL) && a != HL {
return stay;
}
if b == SY && a == HL {
return stay;
}
if a == IN {
return stay;
}
if matches!(b, AL | HL) && a == NU {
return stay;
}
if b == NU && matches!(a, AL | HL) {
return stay;
}
if b == PR && matches!(a, ID | EB | EM) {
return stay;
}
if matches!(b, ID | EB | EM) && a == PO {
return stay;
}
if matches!(b, PR | PO) && matches!(a, AL | HL) {
return stay;
}
if matches!(b, AL | HL) && matches!(a, PR | PO) {
return stay;
}
if matches!(b, PR | PO) {
if a == NU {
return stay;
}
if matches!(a, OP | HY) && self.class_at(end) == Some(NU) {
return stay;
}
}
if matches!(b, OP | HY | IS) && a == NU {
return stay;
}
if self.num == Num::In && matches!(a, NU | SY | IS | CL | CP) {
return stay;
}
if matches!(self.num, Num::In | Num::Closed) && matches!(a, PO | PR) {
return stay;
}
if b == JL && matches!(a, JL | JV | H2 | H3) {
return stay;
}
if matches!(b, JV | H2) && matches!(a, JV | JT) {
return stay;
}
if matches!(b, JT | H3) && a == JT {
return stay;
}
if matches!(b, JL | JV | JT | H2 | H3) && a == PO {
return stay;
}
if b == PR && matches!(a, JL | JV | JT | H2 | H3) {
return stay;
}
if matches!(b, AL | HL) && matches!(a, AL | HL) {
return stay;
}
if b == AP && (ak(cur) || a == AS) {
return stay;
}
if ak(self.prev) && matches!(a, VF | VI) {
return stay;
}
if b == VI && ak(cur) && self.ctx.is_some_and(ak) {
return stay;
}
if ak(self.prev) && ak(cur) && self.class_at(end) == Some(VF) {
return stay;
}
if b == IS && matches!(a, AL | HL) {
return stay;
}
if matches!(b, AL | HL | NU) && a == OP && !cur.ea {
return stay;
}
if b == CP && !self.prev.ea && matches!(a, AL | HL | NU) {
return stay;
}
if b == RI && a == RI && self.ri % 2 == 1 {
return stay;
}
if b == EB && a == EM {
return stay;
}
if self.prev.pict && a == EM {
return stay;
}
brk
}
}