use std::collections::{BTreeMap, VecDeque};
use oneyaml_core::code::{
DEPTH_LIMIT_EXCEEDED, IMPLICIT_KEY_TOO_LONG, INVALID_INDENTATION, MISSING_FLOW_SEPARATOR,
MULTILINE_IMPLICIT_KEY, UNEXPECTED_FLOW_INDICATOR, UNTERMINATED_FLOW_COLLECTION,
};
use oneyaml_core::{Code, Span};
use super::block::HeadMode;
use super::scan::{
IMPLICIT_KEY_MAX_CHARS, TagPrefix, any_marker_at, blank_or_end, break_len, byte, char_at,
comment_at, is_flow_indicator, key_too_long, line_end, mark_at, skip_white,
};
use super::{Item, Out, Parser};
use crate::event::{CollectionStyle, Event, EventKind, Indicator, Properties, TriviaKind};
pub(crate) const KEY_WINDOW: usize = IMPLICIT_KEY_MAX_CHARS.saturating_mul(4);
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Kind {
Seq,
Map,
Pair,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Slot {
Entry { at: usize, pos: usize, line: usize },
Key,
Value,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum State {
Entry,
Node(Slot),
EntryDone {
at: usize,
pos: usize,
line: usize,
json: bool,
peak: usize,
},
AfterKey { json: bool },
AfterEntry,
}
#[derive(Clone, Copy, Debug)]
pub(super) struct Frame {
pub(super) kind: Kind,
pub(super) state: State,
pub(super) peak: usize,
pub(super) open: usize,
}
#[derive(Clone, Debug)]
enum Held<'a> {
Item(Item<'a>),
Reserved,
Empty,
}
#[derive(Debug, Default)]
pub(super) struct FlowState<'a> {
hold: VecDeque<Held<'a>>,
hold_base: usize,
pairs: VecDeque<(usize, usize)>,
pub(super) blame: Option<usize>,
pub(super) out_pos: usize,
pub(super) pos: usize,
pub(super) line_start: usize,
pub(super) line_indent: usize,
pub(super) min: Option<usize>,
pub(super) stack: Vec<Frame>,
pub(super) props: Properties,
pub(super) finished: bool,
pub(super) first_line: usize,
pub(super) open: usize,
pub(super) multiline_key: bool,
pub(super) peak: usize,
pub(super) mode: Option<HeadMode>,
pub(super) head: Vec<Event<'a>>,
pub(super) head_start: usize,
pub(super) head_col: usize,
pub(super) conflicting: bool,
pub(super) released: bool,
}
impl<'a> FlowState<'a> {
pub(super) fn reset(&mut self, start: usize, line_start: usize, line_indent: usize) {
self.hold.clear();
self.pairs.clear();
self.stack.clear();
self.out_pos = start;
self.pos = start;
self.line_start = line_start;
self.line_indent = line_indent;
self.first_line = line_start;
self.open = start;
self.multiline_key = false;
self.finished = false;
self.peak = 0;
self.released = false;
}
pub(super) fn capacity(&self) -> usize {
self.hold
.capacity()
.saturating_add(self.pairs.capacity())
.saturating_add(self.stack.capacity())
.saturating_add(self.head.capacity())
}
pub(super) fn abandon(&mut self) {
self.hold.clear();
self.pairs.clear();
self.stack.clear();
self.mode = None;
}
pub(super) fn first_event(&mut self) -> Option<&mut Event<'a>> {
self.hold.iter_mut().find_map(|h| match h {
Held::Item(Item::Event(e)) => Some(e),
_ => None,
})
}
pub(super) fn holds_events(&self) -> bool {
self.hold
.iter()
.any(|h| matches!(h, Held::Item(Item::Event(_))))
}
fn resolve(&mut self, at: usize, event: Option<Event<'a>>) {
let slot = at
.checked_sub(self.hold_base)
.and_then(|k| self.hold.get_mut(k));
if let Some(slot @ Held::Reserved) = slot {
*slot = event.map_or(Held::Empty, |e| Held::Item(Item::Event(e)));
}
if self.pairs.back().map(|p| p.0) == Some(at) {
self.pairs.pop_back();
}
}
fn new_line(&mut self) {
while let Some((at, _)) = self.pairs.pop_front() {
self.resolve(at, None);
}
}
pub(super) fn expire(&mut self) {
while let Some(&(at, key)) = self.pairs.front() {
if self.pos.saturating_sub(key) <= KEY_WINDOW {
break;
}
self.pairs.pop_front();
self.resolve(at, None);
}
}
pub(super) fn drain(&mut self, out: &mut Out<'a>) {
while let Some(front) = self.hold.front() {
if matches!(front, Held::Reserved) {
break;
}
if let Some(Held::Item(item)) = self.hold.pop_front() {
out.item(item);
}
self.hold_base = self.hold_base.saturating_add(1);
}
}
pub(super) fn drain_all(&mut self, out: &mut Out<'a>) {
self.new_line();
while let Some(held) = self.hold.pop_front() {
if let Held::Item(item) = held {
out.item(item);
}
self.hold_base = self.hold_base.saturating_add(1);
}
}
}
pub(super) type Stop = (Code, &'static str);
pub(super) enum Pause {
Failed(Stop),
Finished,
NotAKey,
Full,
}
pub(super) struct Flow<'s, 'a> {
pub(super) src: &'a str,
pub(super) tags: &'s BTreeMap<&'a str, TagPrefix>,
block_depth: usize,
max_depth: usize,
pub(super) max_scalar_len: usize,
st: &'s mut FlowState<'a>,
out: &'s mut Out<'a>,
}
impl<'a> core::ops::Deref for Flow<'_, 'a> {
type Target = FlowState<'a>;
fn deref(&self) -> &FlowState<'a> {
self.st
}
}
impl<'a> core::ops::DerefMut for Flow<'_, 'a> {
fn deref_mut(&mut self) -> &mut FlowState<'a> {
self.st
}
}
pub(super) fn separated(src: &str, i: usize) -> bool {
blank_or_end(src, i) || char_at(src, i).is_some_and(is_flow_indicator)
}
#[cold]
fn glued_collection() -> Stop {
(
MISSING_FLOW_SEPARATOR,
"a flow collection after `:` needs white space before it unless the key is quoted",
)
}
impl<'s, 'a> Flow<'s, 'a> {
pub(super) fn new(p: &'s mut Parser<'a>) -> Self {
Flow {
src: p.src,
tags: &p.tags,
block_depth: p.stack.len().saturating_sub(1),
max_depth: p.max_depth,
max_scalar_len: p.max_scalar_len,
st: &mut p.flow,
out: &mut p.out,
}
}
pub(super) fn run(&mut self) -> Pause {
loop {
if let Err(stop) = self.step() {
return Pause::Failed(stop);
}
let st = &mut *self.st;
if st.finished {
return Pause::Finished;
}
if !st.released
&& (st.line_start != st.first_line
|| st.pos.saturating_sub(st.head_start) > KEY_WINDOW)
{
return Pause::NotAKey;
}
st.expire();
if st.released {
st.drain(self.out);
}
if self.out.is_full() {
return Pause::Full;
}
}
}
fn emit(&mut self, item: Item<'a>) {
if self.st.released && self.st.hold.is_empty() {
self.out.item(item);
} else {
self.st.hold.push_back(Held::Item(item));
}
}
pub(super) fn push(&mut self, kind: EventKind, start: usize, end: usize) {
self.emit(Item::Event(Event::new(kind, Span::new(start, end))));
self.out_pos = end;
}
fn comment_errors(&mut self, i: usize, end: usize) {
let src = self.src;
let text = src.get(i..end).unwrap_or("");
let mut bad = super::comment_char_diagnostic(src, i, end);
if bad.is_none() && !text.contains('\u{feff}') {
return;
}
self.pos = end;
self.flush();
for (k, _) in text.match_indices('\u{feff}') {
let at = i.saturating_add(k);
if bad.as_ref().is_some_and(|d| d.primary.span.start < at) {
if let Some(d) = bad.take() {
self.zero(EventKind::Error(d));
}
}
let d = super::misplaced_bom_diagnostic(at, at.saturating_add('\u{feff}'.len_utf8()));
self.zero(EventKind::Error(d));
}
if let Some(d) = bad {
self.zero(EventKind::Error(d));
}
}
pub(super) fn zero(&mut self, kind: EventKind) {
let at = self.out_pos;
self.push(kind, at, at);
}
pub(super) fn flush(&mut self) {
let (from, to) = (self.out_pos, self.pos);
if from < to {
self.emit(Item::Trivia(from, to));
}
self.out_pos = to;
}
fn reserve(&mut self) -> usize {
let st = &mut *self.st;
let at = st.hold_base.saturating_add(st.hold.len());
st.hold.push_back(Held::Reserved);
st.pairs.push_back((at, st.pos));
at
}
pub(super) fn crossed_line(&mut self) {
self.st.new_line();
}
pub(super) fn token(&mut self, kind: EventKind, end: usize) {
self.flush();
let start = self.pos;
self.push(kind, start, end);
self.pos = end;
}
#[inline]
fn value_indicator(&mut self, json: bool) -> Result<(), Stop> {
self.indicator(Indicator::MappingValue);
if !json && byte(self.src, self.pos).is_some_and(|b| b & 0xDF == 0x5B) {
return Err(glued_collection());
}
Ok(())
}
fn indicator(&mut self, indicator: Indicator) {
let end = self.pos.saturating_add(1);
self.token(EventKind::Trivia(TriviaKind::Indicator(indicator)), end);
}
fn trivia(&mut self) -> Result<(), Stop> {
let src = self.src;
let mut new_line = false;
let mut lead_marks = 0usize;
loop {
let i = self.pos;
let lead = self
.line_start
.saturating_add(self.line_indent)
.saturating_add(lead_marks);
let end = match byte(src, i) {
Some(b' ' | b'\t') => {
let end = skip_white(src, i);
if i == lead {
let spaces = src
.get(i..end)
.map_or(0, |r| r.bytes().take_while(|b| *b == b' ').count());
self.line_indent = self.line_indent.saturating_add(spaces);
}
end
}
Some(b'\n' | b'\r') => {
let end = i.saturating_add(break_len(src, i));
self.line_start = end;
self.line_indent = 0;
lead_marks = 0;
new_line = true;
end
}
Some(b'#') if comment_at(src, i) => {
let end = line_end(src, i);
self.comment_errors(i, end);
end
}
_ if mark_at(src, i) => {
let end = i.saturating_add('\u{feff}'.len_utf8());
if i == lead {
lead_marks = lead_marks.saturating_add(end.saturating_sub(i));
}
self.flush();
self.push(
EventKind::Error(super::misplaced_bom_diagnostic(i, end)),
i,
end,
);
self.pos = end;
continue;
}
_ => break,
};
self.pos = end;
}
if new_line {
self.crossed_line();
}
if self.pos >= src.len() {
return Err((
UNTERMINATED_FLOW_COLLECTION,
"flow collection is not closed",
));
}
if new_line {
if self.pos == self.line_start && any_marker_at(src, self.pos) {
return Err((
UNTERMINATED_FLOW_COLLECTION,
"document marker inside a flow collection",
));
}
if self.min.is_some_and(|n| self.line_indent <= n) {
return Err((
INVALID_INDENTATION,
"flow content must be indented more than its block parent",
));
}
}
Ok(())
}
fn top(&self) -> Option<Frame> {
self.stack.last().copied()
}
fn next_depth(&self) -> usize {
self.block_depth
.saturating_add(self.stack.len())
.saturating_add(1)
}
pub(super) fn check_depth(&self, depth: usize) -> Result<(), Stop> {
if depth <= self.max_depth {
Ok(())
} else {
Err((DEPTH_LIMIT_EXCEEDED, "collections are nested too deeply"))
}
}
pub(super) fn push_frame(&mut self, kind: Kind, state: State) -> Result<(), Stop> {
let depth = self.next_depth();
self.check_depth(depth)?;
let open = self.pos;
self.stack.push(Frame {
kind,
state,
peak: depth,
open,
});
self.peak = self.peak.max(depth);
Ok(())
}
pub(super) fn pop_frame(&mut self) -> Option<Frame> {
let frame = self.stack.pop()?;
if let Some(parent) = self.stack.last_mut() {
parent.peak = parent.peak.max(frame.peak);
}
Some(frame)
}
fn set(&mut self, state: State) {
if let Some(top) = self.stack.last_mut() {
top.state = state;
}
}
pub(super) fn step(&mut self) -> Result<(), Stop> {
let Some(top) = self.top() else {
return self.node();
};
self.trivia()?;
let src = self.src;
let i = self.pos;
let c = byte(src, i);
let sep = separated(src, i.saturating_add(1));
let closer = if top.kind == Kind::Map { b'}' } else { b']' };
match (top.kind, top.state) {
(_, State::Node(_)) => self.node(),
(Kind::Seq | Kind::Map, State::Entry) if c == Some(closer) => self.close(),
(_, State::Entry) if matches!(c, Some(b',' | b']' | b'}')) => {
Err((UNEXPECTED_FLOW_INDICATOR, "expected an entry"))
}
(kind, State::Entry) if c == Some(b'?') && sep => {
self.flush();
if kind == Kind::Seq {
self.push_frame(Kind::Pair, State::Node(Slot::Key))?;
self.zero(EventKind::mapping_start(CollectionStyle::FlowPair));
} else {
self.set(State::Node(Slot::Key));
}
self.indicator(Indicator::MappingKey);
Ok(())
}
(kind, State::Entry) if c == Some(b':') && sep => {
self.flush();
if kind == Kind::Seq {
self.push_frame(Kind::Pair, State::Node(Slot::Value))?;
self.zero(EventKind::mapping_start(CollectionStyle::FlowPair));
} else {
self.set(State::Node(Slot::Value));
}
self.empty();
self.value_indicator(false)
}
(Kind::Seq, State::Entry) => {
self.flush();
let at = self.reserve();
let (pos, line) = (self.pos, self.line_start);
self.set(State::Node(Slot::Entry { at, pos, line }));
Ok(())
}
(_, State::Entry) => {
self.set(State::Node(Slot::Key));
Ok(())
}
(
_,
State::EntryDone {
at,
pos,
line,
json,
peak,
},
) => {
let pair = c == Some(b':') && self.line_start == line && (json || sep);
if pair && key_too_long(src, pos, i) {
self.blame = Some(i.saturating_add(1));
return Err((
IMPLICIT_KEY_TOO_LONG,
"an implicit key must be at most 1024 characters",
));
}
if pair {
if peak > 0 {
self.check_depth(peak.saturating_add(1))?;
}
self.push_frame(Kind::Pair, State::Node(Slot::Value))?;
let key_peak = peak.saturating_add(1);
if let Some(top) = self.stack.last_mut() {
top.peak = top.peak.max(key_peak);
}
self.peak = self.peak.max(key_peak);
let start = EventKind::mapping_start(CollectionStyle::FlowPair);
self.st
.resolve(at, Some(Event::new(start, Span::empty(pos))));
self.value_indicator(json)?;
} else {
self.st.resolve(at, None);
self.set(State::AfterEntry);
}
Ok(())
}
(kind, State::AfterKey { json }) => {
if c == Some(b':') && (json || sep) {
self.set(State::Node(Slot::Value));
return self.value_indicator(json);
}
if !matches!(c, Some(b',' | b']' | b'}')) {
return Err((
MISSING_FLOW_SEPARATOR,
"expected `:`, `,`, or the end of the collection",
));
}
self.empty();
if kind == Kind::Pair {
self.close_pair();
} else {
self.set(State::AfterEntry);
}
Ok(())
}
(_, State::AfterEntry) => match c {
Some(b',') => {
self.set(State::Entry);
self.indicator(Indicator::FlowEntry);
Ok(())
}
Some(x) if x == closer => self.close(),
Some(b']' | b'}') => Err((UNEXPECTED_FLOW_INDICATOR, "mismatched closing bracket")),
Some(b':') if top.kind == Kind::Seq => Err((
MULTILINE_IMPLICIT_KEY,
"an implicit key must be on one line with its `:`",
)),
_ => Err((
MISSING_FLOW_SEPARATOR,
"flow entries must be separated by `,`",
)),
},
}
}
}