use crate::{
Error,
lex::{Lexer, Token},
parse::{apply, is_keyword},
value::Scratch,
};
use core::hash::{BuildHasher, Hash, Hasher};
use nsi_trait::Nsi;
use rayon::prelude::*;
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
enum Phase {
Create,
Modify,
Barrier,
}
#[derive(Copy, Clone, Debug)]
struct Statement {
phase: Phase,
start: usize,
key: u64,
}
fn phase_and_operands(keyword: &str) -> (Phase, usize, usize) {
match keyword {
"Create" => (Phase::Create, 0, 1),
"SetAttribute" | "SetAttributeAtTime" => (Phase::Modify, 0, 1),
"Connect" => (Phase::Modify, 2, 2),
_ => (Phase::Barrier, 0, 0),
}
}
const ENDS_WORD: [bool; 256] = {
let mut table = [false; 256];
let mut byte = 0;
while byte < 256 {
table[byte] = (byte as u8).is_ascii_whitespace()
|| matches!(byte as u8, b'[' | b']' | b'"' | b'#');
byte += 1;
}
table
};
fn scan(input: &[u8]) -> Option<Vec<Statement>> {
let hasher = ahash::RandomState::new();
let mut statements = Vec::new();
let mut current: Option<(Statement, ahash::AHasher, usize, usize)> = None;
let mut position = 0;
while let Some(&byte) = input.get(position) {
match byte {
_ if byte.is_ascii_whitespace() => position += 1,
b'#' => {
position = memchr::memchr(b'\n', &input[position..])
.map_or(input.len(), |end| position + end);
}
b'"' => {
let open = position;
let mut cursor = open + 1;
let close = loop {
match memchr::memchr2(b'"', b'\\', &input[cursor..]) {
None => break input.len(),
Some(at) if input[cursor + at] == b'\\' => {
cursor += at + 2
}
Some(at) => break cursor + at,
}
};
position = close + 1;
let (_, key, skip, take) = current.as_mut()?;
if 0 < *skip {
*skip -= 1;
} else if 0 < *take {
let raw = &input[(open + 1).min(close)..close];
match raw.contains(&b'\\') {
true => crate::lex::unescape(raw, open)
.unwrap_or_else(|_| raw.to_vec())
.hash(key),
false => raw.hash(key),
}
*take -= 1;
}
}
b'[' | b']' => {
current.as_mut()?.3 = 0;
position += 1;
}
_ => {
let start = position;
while input
.get(position)
.is_some_and(|&b| !ENDS_WORD[b as usize])
{
position += 1;
}
let word = &input[start..position];
let keyword = word
.first()
.is_some_and(u8::is_ascii_uppercase)
.then(|| core::str::from_utf8(word).ok())
.flatten()
.filter(|word| is_keyword(word));
match keyword {
Some(keyword) => {
statements.extend(current.take().map(finish));
let (phase, skip, take) = phase_and_operands(keyword);
current = Some((
Statement {
phase,
start,
key: 0,
},
hasher.build_hasher(),
skip,
take,
));
}
None => current.as_mut()?.3 = 0,
}
}
}
}
statements.extend(current.map(finish));
Some(statements)
}
fn finish(
(statement, key, _, _): (Statement, ahash::AHasher, usize, usize),
) -> Statement {
Statement {
key: key.finish(),
..statement
}
}
fn apply_one<'a, N>(
input: &'a [u8],
start: usize,
end: usize,
sink: &N,
scratch: &mut Scratch<'a>,
) -> Result<(), Error<N::Error>>
where
N: Nsi,
for<'call> N: Nsi<Arg<'call> = nsi_ffi_wrap::Arg<'call, 'static>>,
{
let mut lexer = Lexer::starting_at(input, start);
let Some(Token::Word(keyword)) = lexer.next_token()? else {
unreachable!("the scan starts every statement at its keyword")
};
let next = match apply(keyword, &mut lexer, sink, scratch)? {
Some(token) => Some(token),
None => lexer.next_token()?,
};
match next {
None => Ok(()),
Some(Token::Word(word)) if is_keyword(word) => {
debug_assert_eq!(lexer.offset(), end);
Ok(())
}
Some(_) => Err(Error::Syntax {
offset: lexer.offset(),
expected: "a statement keyword",
}),
}
}
fn run_phase<N>(
input: &[u8],
statements: &[Statement],
mut indices: Vec<usize>,
sink: &N,
) -> Result<(), Error<N::Error>>
where
N: Nsi + Sync,
for<'call> N: Nsi<Arg<'call> = nsi_ffi_wrap::Arg<'call, 'static>>,
{
indices.sort_by_key(|&index| statements[index].key);
let end_of = |index: usize| {
statements
.get(index + 1)
.map_or(input.len(), |next| next.start)
};
indices
.par_chunk_by(|&a, &b| statements[a].key == statements[b].key)
.map_init(Scratch::default, |scratch, group| {
group.iter().find_map(|&index| {
let start = statements[index].start;
apply_one(input, start, end_of(index), sink, scratch)
.err()
.map(|error| (start, error))
})
})
.flatten()
.min_by_key(|(start, _)| *start)
.map_or(Ok(()), |(_, error)| Err(error))
}
pub(crate) fn parse<N>(input: &[u8], sink: &N) -> Result<(), Error<N::Error>>
where
N: Nsi + Sync,
for<'call> N: Nsi<Arg<'call> = nsi_ffi_wrap::Arg<'call, 'static>>,
{
let Some(statements) = scan(input) else {
return crate::parse::parse(input, sink);
};
let mut segment_start = 0;
for (index, statement) in statements.iter().enumerate() {
let is_last = index + 1 == statements.len();
if statement.phase != Phase::Barrier && !is_last {
continue;
}
let segment_end = if statement.phase == Phase::Barrier {
index
} else {
index + 1
};
let phase = |wanted: Phase| {
(segment_start..segment_end)
.filter(|&i| statements[i].phase == wanted)
.collect::<Vec<_>>()
};
run_phase(input, &statements, phase(Phase::Create), sink)?;
run_phase(input, &statements, phase(Phase::Modify), sink)?;
if statement.phase == Phase::Barrier {
let end = statements
.get(index + 1)
.map_or(input.len(), |next| next.start);
apply_one(
input,
statement.start,
end,
sink,
&mut Scratch::default(),
)?;
}
segment_start = index + 1;
}
Ok(())
}