use crate::{
Error,
lex::{Ident, Lexer, Token},
value::{self, Scratch},
};
use nsi_trait::Nsi;
const KEYWORDS: [&str; 9] = [
"Create",
"SetAttribute",
"SetAttributeAtTime",
"Delete",
"DeleteAttribute",
"Connect",
"Disconnect",
"Evaluate",
"RenderControl",
];
pub(crate) fn is_keyword(word: &str) -> bool {
KEYWORDS.contains(&word)
}
pub(crate) fn parse<N>(input: &[u8], sink: &N) -> Result<(), Error<N::Error>>
where
N: Nsi,
for<'call> N: Nsi<Arg<'call> = nsi_ffi_wrap::Arg<'call, 'static>>,
{
let mut lexer = Lexer::new(input);
let mut pending = lexer.next_token()?;
let mut scratch = Scratch::default();
while let Some(token) = pending.take() {
let offset = lexer.offset();
let Token::Word(keyword) = token else {
return Err(Error::Syntax {
offset,
expected: "a statement keyword",
});
};
if !is_keyword(keyword) {
return Err(Error::Syntax {
offset,
expected: "a statement keyword",
});
}
pending = apply(keyword, &mut lexer, sink, &mut scratch)?;
if pending.is_none() {
pending = lexer.next_token()?;
}
}
Ok(())
}
pub(crate) fn apply<'a, N>(
keyword: &str,
lexer: &mut Lexer<'a>,
sink: &N,
scratch: &mut Scratch<'a>,
) -> Result<Option<Token<'a>>, Error<N::Error>>
where
N: Nsi,
for<'call> N: Nsi<Arg<'call> = nsi_ffi_wrap::Arg<'call, 'static>>,
{
match keyword {
"Create" => {
let handle = string(lexer, "a node handle")?;
let node_type = string(lexer, "a node type")?;
let next = parameters(lexer, scratch)?;
scratch
.with_args(|args| {
sink.create(handle.as_str(), node_type.as_str(), Some(args))
})
.map_err(Error::Sink)?;
Ok(next)
}
"Delete" => {
let handle = string(lexer, "a node handle")?;
let next = parameters(lexer, scratch)?;
scratch
.with_args(|args| sink.delete(handle.as_str(), Some(args)))
.map_err(Error::Sink)?;
Ok(next)
}
"DeleteAttribute" => {
let handle = string(lexer, "a node handle")?;
let name = string(lexer, "an attribute name")?;
sink.delete_attribute(handle.as_str(), name.as_str())
.map_err(Error::Sink)?;
Ok(None)
}
"SetAttribute" => {
let handle = string(lexer, "a node handle")?;
let next = parameters(lexer, scratch)?;
scratch
.with_args(|args| sink.set_attribute(handle.as_str(), args))
.map_err(Error::Sink)?;
Ok(next)
}
"SetAttributeAtTime" => {
let handle = string(lexer, "a node handle")?;
let time = number(lexer)?;
let next = parameters(lexer, scratch)?;
scratch
.with_args(|args| {
sink.set_attribute_at_time(handle.as_str(), time, args)
})
.map_err(Error::Sink)?;
Ok(next)
}
"Connect" | "Disconnect" => {
let from = string(lexer, "a source handle")?;
let from_attribute = string(lexer, "a source attribute")?;
let to = string(lexer, "a destination handle")?;
let to_attribute = string(lexer, "a destination attribute")?;
let port = Some(from_attribute.as_str()).filter(|p| !p.is_empty());
if keyword == "Connect" {
let next = parameters(lexer, scratch)?;
scratch
.with_args(|args| {
sink.connect(
from.as_str(),
port,
to.as_str(),
to_attribute.as_str(),
Some(args),
)
})
.map_err(Error::Sink)?;
Ok(next)
} else {
sink.disconnect(
from.as_str(),
port,
to.as_str(),
to_attribute.as_str(),
)
.map_err(Error::Sink)?;
Ok(None)
}
}
"Evaluate" => {
let next = parameters(lexer, scratch)?;
scratch
.with_args(|args| sink.evaluate(args))
.map_err(Error::Sink)?;
Ok(next)
}
"RenderControl" => {
let next = parameters(lexer, scratch)?;
let action = scratch.action().ok_or(Error::Syntax {
offset: lexer.offset(),
expected: "a RenderControl action",
})?;
scratch
.with_args_except(Some("action"), |args| {
sink.render_control(action, Some(args))
})
.map_err(Error::Sink)?;
Ok(next)
}
_ => unreachable!("dispatched on a keyword"),
}
}
fn string<'a, E>(
lexer: &mut Lexer<'a>,
expected: &'static str,
) -> Result<Ident<'a>, Error<E>> {
match lexer.next_token()? {
Some(Token::Quoted(text)) => Ok(text.into_ident(lexer.offset())?),
_ => Err(Error::Syntax {
offset: lexer.offset(),
expected,
}),
}
}
fn number<E>(lexer: &mut Lexer<'_>) -> Result<f64, Error<E>> {
match lexer.next_token()? {
Some(Token::Word(text)) => text.parse().map_err(|_| Error::Syntax {
offset: lexer.offset(),
expected: "a number",
}),
_ => Err(Error::Syntax {
offset: lexer.offset(),
expected: "a number",
}),
}
}
fn parameters<'a, E>(
lexer: &mut Lexer<'a>,
scratch: &mut Scratch<'a>,
) -> Result<Option<Token<'a>>, Error<E>> {
scratch.clear();
loop {
match lexer.next_token()? {
Some(Token::Quoted(name)) => {
let name = name.into_ident(lexer.offset())?.into_cow();
value::read(name, lexer, scratch)?;
}
other => return Ok(other),
}
}
}