use bytes::BytesMut;
use parse_common::error::{RenderedError, SyntaxError};
use super::entry::{self, Statement};
use super::query::TopLevelExpr;
use super::settings::ParserSettings;
pub struct StatementStream {
settings: ParserSettings,
col_offset: usize,
line_offset: usize,
}
impl Default for StatementStream {
fn default() -> Self {
Self::new()
}
}
impl StatementStream {
pub fn new() -> Self {
Self::new_with_settings(ParserSettings::default())
}
pub fn new_with_settings(settings: ParserSettings) -> Self {
StatementStream {
settings,
col_offset: 0,
line_offset: 0,
}
}
fn accumulate_line_col(&mut self, bytes: &[u8]) {
let (line_num, remaining) = std::str::from_utf8(bytes)
.expect("parser validated utf8")
.lines()
.enumerate()
.last()
.unwrap_or((0, ""));
self.line_offset += line_num;
if line_num > 0 {
self.col_offset = 0;
}
self.col_offset += remaining.chars().count();
}
pub fn parse_partial(
&mut self,
buffer: &mut BytesMut,
) -> Result<Option<TopLevelExpr>, RenderedError> {
self.parse(buffer, false)
}
pub fn parse_complete(
&mut self,
buffer: &mut BytesMut,
) -> Result<Option<TopLevelExpr>, RenderedError> {
self.parse(buffer, true)
}
fn parse(
&mut self,
buffer: &mut BytesMut,
complete: bool,
) -> Result<Option<TopLevelExpr>, RenderedError> {
let slice = &buffer[..buffer.len().min(u32::MAX as usize)];
let mut invalid = false;
let src = match std::str::from_utf8(slice) {
Ok(s) => s,
Err(e) => {
invalid = e.error_len().is_some() || complete;
std::str::from_utf8(&slice[..e.valid_up_to()]).expect("validated prefix")
}
};
let complete = complete && !invalid && src.len() == buffer.len();
let parsed = entry::statement(src, &self.settings.next(), complete);
if invalid && matches!(parsed, Statement::NeedMore | Statement::Empty { .. }) {
return Err(SyntaxError::new("Invalid, non valid UTF-8 bytes, in source")
.render_on(src)
.offset_location(self.line_offset, self.col_offset));
}
match parsed {
Statement::Empty {
consumed,
} => {
let eaten = buffer.split_to(consumed as usize);
self.accumulate_line_col(&eaten);
Ok(None)
}
Statement::NeedMore => Ok(None),
Statement::Parsed {
stmt,
consumed,
} => {
let eaten = buffer.split_to(consumed as usize);
self.accumulate_line_col(&eaten);
Ok(Some(*stmt))
}
Statement::Rejected(e) => {
Err(super::api::render(src, &e).offset_location(self.line_offset, self.col_offset))
}
}
}
}