use crate::tables::{entry, GCB_MASK, GCB_SHIFT};
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[repr(u8)]
pub(crate) enum Gcb {
Other = 0,
Cr = 1,
Lf = 2,
Control = 3,
Extend = 4,
Zwj = 5,
RegionalIndicator = 6,
Prepend = 7,
SpacingMark = 8,
L = 9,
V = 10,
T = 11,
Lv = 12,
Lvt = 13,
ExtPict = 14,
InCBLinker = 15,
InCBConsonant = 16,
InCBExtend = 17,
}
#[rustfmt::skip]
const GCB_TABLE: [Gcb; 32] = {
use Gcb::*;
[
Other, Cr, Lf, Control, Extend, Zwj, RegionalIndicator, Prepend,
SpacingMark, L, V, T, Lv, Lvt, ExtPict, InCBLinker, InCBConsonant,
InCBExtend, Other, Other, Other, Other, Other, Other, Other, Other,
Other, Other, Other, Other, Other, Other,
]
};
impl Gcb {
fn is_extend_like(self) -> bool {
matches!(
self,
Gcb::Extend | Gcb::InCBExtend | Gcb::InCBLinker | Gcb::Zwj
)
}
fn is_incb_extend(self) -> bool {
matches!(self, Gcb::InCBExtend | Gcb::InCBLinker | Gcb::Zwj)
}
}
pub(crate) fn gcb(c: char) -> Gcb {
GCB_TABLE[((entry(c as u32) >> GCB_SHIFT) & GCB_MASK) as usize]
}
#[derive(Default, Clone)]
pub(crate) struct Breaker {
prev: Option<Gcb>,
ri_run: usize,
pict_seq: bool,
incb_consonant: bool,
incb_linker: bool,
legacy: bool,
}
impl Breaker {
pub(crate) fn legacy() -> Self {
Breaker {
legacy: true,
..Breaker::default()
}
}
pub(crate) fn is_boundary(&mut self, c: char) -> bool {
let right = gcb(c);
let brk = match self.prev {
None => true, Some(left) => self.decide(left, right),
};
self.advance(right, brk);
brk
}
fn decide(&self, l: Gcb, r: Gcb) -> bool {
if l == Gcb::Cr && r == Gcb::Lf {
return false;
}
if matches!(l, Gcb::Cr | Gcb::Lf | Gcb::Control)
|| matches!(r, Gcb::Cr | Gcb::Lf | Gcb::Control)
{
return true;
}
if l == Gcb::L && matches!(r, Gcb::L | Gcb::V | Gcb::Lv | Gcb::Lvt) {
return false;
}
if matches!(l, Gcb::Lv | Gcb::V) && matches!(r, Gcb::V | Gcb::T) {
return false;
}
if matches!(l, Gcb::Lvt | Gcb::T) && r == Gcb::T {
return false;
}
if r.is_extend_like() {
return false;
}
if !self.legacy {
if r == Gcb::SpacingMark || l == Gcb::Prepend {
return false;
}
if r == Gcb::InCBConsonant && self.incb_consonant && self.incb_linker {
return false;
}
}
if l == Gcb::Zwj && self.pict_seq && r == Gcb::ExtPict {
return false;
}
if l == Gcb::RegionalIndicator && r == Gcb::RegionalIndicator && self.ri_run % 2 == 1 {
return false;
}
true }
fn advance(&mut self, r: Gcb, brk: bool) {
self.ri_run = if r == Gcb::RegionalIndicator {
if brk {
1
} else {
self.ri_run + 1
}
} else {
0
};
if r == Gcb::ExtPict {
self.pict_seq = true;
} else if !matches!(
r,
Gcb::Extend | Gcb::InCBExtend | Gcb::InCBLinker | Gcb::Zwj
) {
self.pict_seq = false;
}
if r == Gcb::InCBConsonant {
self.incb_consonant = true;
self.incb_linker = false;
} else if r == Gcb::InCBLinker {
if self.incb_consonant {
self.incb_linker = true;
}
} else if !r.is_incb_extend() {
self.incb_consonant = false;
self.incb_linker = false;
}
self.prev = Some(r);
}
}
#[derive(Clone)]
pub struct Graphemes<'a> {
s: &'a str,
start: usize,
pos: usize,
breaker: Breaker,
}
impl<'a> Graphemes<'a> {
pub(crate) fn new(s: &'a str) -> Self {
Graphemes {
s,
start: 0,
pos: 0,
breaker: Breaker::default(),
}
}
pub(crate) fn new_legacy(s: &'a str) -> Self {
Graphemes {
breaker: Breaker::legacy(),
..Graphemes::new(s)
}
}
pub fn remainder(&self) -> &'a str {
&self.s[self.start..]
}
}
impl<'a> Iterator for Graphemes<'a> {
type Item = &'a str;
fn next(&mut self) -> Option<&'a str> {
if self.start >= self.s.len() {
return None;
}
while let Some(c) = self.s[self.pos..].chars().next() {
let at = self.pos;
if self.breaker.is_boundary(c) && at > self.start {
let cluster = &self.s[self.start..at];
self.start = at;
self.pos = at + c.len_utf8();
return Some(cluster);
}
self.pos = at + c.len_utf8();
}
let cluster = &self.s[self.start..];
self.start = self.s.len();
Some(cluster)
}
fn size_hint(&self) -> (usize, Option<usize>) {
let bytes = self.s.len() - self.start;
((bytes != 0) as usize, Some(bytes))
}
}
impl core::iter::FusedIterator for Graphemes<'_> {}
pub(crate) fn first_cluster(s: &str) -> &str {
Graphemes::new(s).next().unwrap_or("")
}
#[cfg(feature = "alloc")]
pub(crate) fn attaches_to_previous(c: char) -> bool {
matches!(
gcb(c),
Gcb::Extend
| Gcb::SpacingMark
| Gcb::Zwj
| Gcb::InCBExtend
| Gcb::InCBLinker
| Gcb::V
| Gcb::T
)
}