nanobrush / crates /mb3-txt /src /parser.rs
nmarshall's picture
formats: add txt conversion cli
18d65b9
Raw History Blame Contribute Delete
16.1 kB
use super::*;
use mb3_dat::{Brush, Patch9, PatchComputed, Plane, Property, Uv, Vec3, World};
#[derive(Clone, Copy, PartialEq)]
enum Kind<'a> {
Word(&'a str),
Number(&'a str, bool),
Str(&'a str),
Symbol(u8),
End,
}
#[derive(Clone, Copy)]
struct Token<'a> {
kind: Kind<'a>,
at: usize,
}
struct Parser<'a> {
source: &'a str,
pos: usize,
look: Option<Token<'a>>,
limits: &'a Limits,
budget: Budget,
}
impl<'a> Parser<'a> {
fn lex(&mut self) -> Result<Token<'a>> {
let bytes = self.source.as_bytes();
loop {
while self.pos < bytes.len() && matches!(bytes[self.pos], b' ' | b'\t' | b'\r' | b'\n')
{
self.pos += 1;
}
if bytes.get(self.pos..self.pos.saturating_add(2)) == Some(b"//") {
self.pos += 2;
while self.pos < bytes.len() && !matches!(bytes[self.pos], b'\r' | b'\n') {
self.pos += 1;
}
} else if bytes.get(self.pos..self.pos.saturating_add(2)) == Some(b"/*") {
let at = self.pos;
self.pos += 2;
while self.pos + 1 < bytes.len() && &bytes[self.pos..self.pos + 2] != b"*/" {
self.pos += 1;
}
if self.pos + 1 >= bytes.len() {
return Err(err(at, ErrorKind::UnterminatedComment));
}
self.pos += 2;
} else {
break;
}
}
let at = self.pos;
let kind = match bytes.get(at).copied() {
None => Kind::End,
Some(b'(' | b')' | b'[' | b']' | b',') => {
self.pos += 1;
Kind::Symbol(bytes[at])
}
Some(b'"') => {
self.pos += 1;
let start = self.pos;
while self.pos < bytes.len() && bytes[self.pos] != b'"' {
match bytes[self.pos] {
0 => return Err(err(self.pos, ErrorKind::EmbeddedNul)),
b'\'' => {
return Err(err(self.pos, ErrorKind::Syntax("escape single quote")));
}
b'\\' => {
self.pos += 1;
if !matches!(
bytes.get(self.pos),
Some(b'r' | b'n' | b't' | b'\'' | b'"' | b'\\')
) {
return Err(err(self.pos, ErrorKind::InvalidEscape));
}
}
_ => (),
}
self.pos += 1;
}
if self.pos == bytes.len() {
return Err(err(at, ErrorKind::UnterminatedString));
}
let raw = &self.source[start..self.pos];
self.pos += 1;
Kind::Str(raw)
}
Some(b'a'..=b'z' | b'A'..=b'Z' | b'_' | b'$') => {
self.pos += 1;
while matches!(
bytes.get(self.pos),
Some(b'a'..=b'z' | b'A'..=b'Z' | b'_' | b'$' | b'0'..=b'9')
) {
self.pos += 1;
}
Kind::Word(&self.source[at..self.pos])
}
Some(b'+' | b'-' | b'.' | b'0'..=b'9') => {
if matches!(bytes[self.pos], b'+' | b'-') {
self.pos += 1;
}
let digits = self.pos;
self.digits(at)?;
let before = self.pos - digits;
let dot = bytes.get(self.pos) == Some(&b'.');
let mut after = 0;
if dot {
self.pos += 1;
let start = self.pos;
self.digits(at)?;
after = self.pos - start;
}
if before + after == 0 {
return Err(err(at, ErrorKind::InvalidNumber));
}
let exponent = matches!(bytes.get(self.pos), Some(b'e' | b'E'));
if exponent {
self.pos += 1;
if matches!(bytes.get(self.pos), Some(b'+' | b'-')) {
self.pos += 1;
}
let start = self.pos;
self.digits(at)?;
if start == self.pos {
return Err(err(at, ErrorKind::InvalidNumber));
}
}
if self.pos - at > 128 {
return Err(err(at, ErrorKind::LimitExceeded("numeric token bytes")));
}
if !dot && before > 1 && bytes[digits] == b'0' {
return Err(err(at, ErrorKind::InvalidNumber));
}
Kind::Number(&self.source[at..self.pos], !dot && !exponent)
}
_ => return Err(err(at, ErrorKind::Syntax("unexpected character"))),
};
Ok(Token { kind, at })
}
fn digits(&mut self, at: usize) -> Result<()> {
while matches!(self.source.as_bytes().get(self.pos), Some(b'0'..=b'9')) {
self.pos += 1;
if self.pos - at > 128 {
return Err(err(at, ErrorKind::LimitExceeded("numeric token bytes")));
}
}
Ok(())
}
fn peek(&mut self) -> Result<Token<'a>> {
if let Some(token) = self.look {
return Ok(token);
}
let token = self.lex()?;
self.look = Some(token);
Ok(token)
}
fn next(&mut self) -> Result<Token<'a>> {
let token = self.peek()?;
self.look = None;
Ok(token)
}
fn is(&mut self, kind: Kind<'a>) -> Result<bool> {
Ok(self.peek()?.kind == kind)
}
fn expect(&mut self, kind: Kind<'a>, message: &'static str) -> Result<()> {
let token = self.next()?;
if token.kind != kind {
return Err(err(token.at, ErrorKind::Syntax(message)));
}
Ok(())
}
fn symbol(&mut self, symbol: u8) -> Result<()> {
self.expect(Kind::Symbol(symbol), "expected punctuation")
}
fn word(&mut self, word: &'static str) -> Result<()> {
self.expect(Kind::Word(word), "expected keyword")
}
fn push<T>(&mut self, out: &mut Vec<T>, value: T) -> Result<()> {
self.budget.push(out, value, self.limits, self.pos)
}
fn string(&mut self) -> Result<String> {
let token = self.next()?;
let Kind::Str(raw) = token.kind else {
return Err(err(token.at, ErrorKind::Syntax("expected string")));
};
let mut out = String::new();
let mut chars = raw.chars();
while let Some(c) = chars.next() {
let c = if c == '\\' {
match chars.next() {
Some('r') => '\r',
Some('n') => '\n',
Some('t') => '\t',
Some('\'') => '\'',
Some('"') => '"',
Some('\\') => '\\',
_ => return Err(err(token.at, ErrorKind::InvalidEscape)),
}
} else {
c
};
let n = out
.len()
.checked_add(c.len_utf8())
.ok_or_else(|| err(token.at, ErrorKind::CountOverflow))?;
if n > self.limits.max_string_bytes {
return Err(err(token.at, ErrorKind::LimitExceeded("string bytes")));
}
if n > out.capacity() {
let cap = n
.max(out.capacity().saturating_mul(2))
.min(self.limits.max_string_bytes);
self.budget
.bytes(cap - out.capacity(), self.limits, token.at)?;
out.try_reserve_exact(cap - out.len())
.map_err(|_| err(token.at, ErrorKind::Allocation))?;
}
out.push(c);
}
Ok(out)
}
fn integer(&mut self) -> Result<u32> {
let token = self.next()?;
let Kind::Number(raw, true) = token.kind else {
return Err(err(
token.at,
ErrorKind::Syntax("expected nonnegative integer"),
));
};
let n = raw
.parse::<i32>()
.map_err(|_| err(token.at, ErrorKind::InvalidNumber))?;
u32::try_from(n).map_err(|_| err(token.at, ErrorKind::InvalidNumber))
}
fn float(&mut self) -> Result<f32> {
let token = self.next()?;
let Kind::Number(raw, _) = token.kind else {
return Err(err(token.at, ErrorKind::Syntax("expected number")));
};
let n = raw
.parse::<f32>()
.map_err(|_| err(token.at, ErrorKind::InvalidNumber))?;
if !n.is_finite() {
return Err(err(token.at, ErrorKind::NonFinite));
}
Ok(n)
}
fn vector(&mut self) -> Result<Vec3> {
Ok([self.float()?, self.float()?, self.float()?])
}
fn vectors(&mut self) -> Result<Vec<Vec3>> {
self.symbol(b'[')?;
let mut out = Vec::new();
if !self.is(Kind::Symbol(b']'))? {
loop {
let v = self.vector()?;
self.push(&mut out, v)?;
if !self.is(Kind::Symbol(b','))? {
break;
}
self.next()?;
}
}
self.symbol(b']')?;
Ok(out)
}
fn names(&mut self) -> Result<Vec<String>> {
self.symbol(b'[')?;
let mut out = Vec::new();
if !self.is(Kind::Symbol(b']'))? {
loop {
let s = self.string()?;
self.push(&mut out, s)?;
if !self.is(Kind::Symbol(b','))? {
break;
}
self.next()?;
}
}
self.symbol(b']')?;
unique_names(&out, &mut self.budget, self.limits, self.pos)?;
Ok(out)
}
fn properties<T>(
&mut self,
key: &'static str,
names: usize,
mut value: impl FnMut(&mut Self) -> Result<T>,
) -> Result<Vec<Property<T>>> {
let mut out = Vec::new();
while self.is(Kind::Word(key))? {
self.next()?;
let at = self.pos;
let index = self.integer()?;
if index as usize >= names {
return Err(err(at, ErrorKind::PropertyIndex(index)));
}
if out.len() >= names {
return Err(err(at, ErrorKind::DuplicateProperty(index)));
}
let entry = Property {
index,
value: value(self)?,
};
self.push(&mut out, entry)?;
}
out.sort_unstable_by_key(|p| p.index);
for pair in out.windows(2) {
if pair[0].index == pair[1].index {
return Err(err(self.pos, ErrorKind::DuplicateProperty(pair[0].index)));
}
}
Ok(out)
}
fn uv(&mut self) -> Result<Uv> {
self.symbol(b'(')?;
let u = self.vector()?;
let u_scale = self.float()?;
let u_shift = self.float()?;
self.symbol(b',')?;
let v = self.vector()?;
let v_scale = self.float()?;
let v_shift = self.float()?;
self.symbol(b')')?;
Ok(Uv {
u,
v,
u_scale,
u_shift,
v_scale,
v_shift,
})
}
fn brush(&mut self, world: &World) -> Result<Brush> {
self.word("brush")?;
self.symbol(b'(')?;
let mut planes = Vec::new();
while self.is(Kind::Word("plane"))? {
self.next()?;
self.symbol(b'(')?;
let p0 = self.vector()?;
self.symbol(b',')?;
let u = self.vector()?;
self.symbol(b',')?;
let v = self.vector()?;
let strings = self.properties("s", world.string_properties.len(), Self::string)?;
let uv = self.properties("uv", world.uv_properties.len(), Self::uv)?;
let polygon = if self.is(Kind::Word("polygon"))? {
self.next()?;
Some(self.vectors()?)
} else {
None
};
if polygon.is_some() != world.computed {
return Err(err(self.pos, ErrorKind::InconsistentComputedData));
}
self.symbol(b')')?;
self.push(
&mut planes,
Plane {
p0,
u,
v,
strings,
uv,
polygon,
},
)?;
}
self.symbol(b')')?;
Ok(Brush { planes })
}
fn patch(&mut self, computed: bool) -> Result<Patch9> {
self.word("patch9")?;
self.symbol(b'(')?;
let au = self.integer()?;
let av = self.integer()?;
let qu = self.integer()?;
let qv = self.integer()?;
self.word("anchors")?;
let anchors = self.vectors()?;
if anchors.len() != product(au as usize, av as usize, self.pos)? {
return Err(err(self.pos, ErrorKind::InvalidPatchLength));
}
let data = if self.is(Kind::Word("points"))? {
self.next()?;
let points = self.vectors()?;
self.word("normals")?;
let normals = self.vectors()?;
let n = grid(au, av, qu, qv, self.pos)?;
if points.len() != n || normals.len() != n {
return Err(err(self.pos, ErrorKind::InvalidPatchLength));
}
Some(PatchComputed { points, normals })
} else {
None
};
if data.is_some() != computed {
return Err(err(self.pos, ErrorKind::InconsistentComputedData));
}
self.symbol(b')')?;
Ok(Patch9 {
anchors_u: au,
anchors_v: av,
quads_u: qu,
quads_v: qv,
anchors,
computed: data,
})
}
}
/// Parse one complete TXT world with the latest grammar (including the older
/// property-free subset). Strict UTF-8, optional leading BOM, bounded ownership.
pub fn decode(bytes: &[u8], limits: &Limits) -> Result<World> {
if bytes.len() > limits.max_bytes {
return Err(err(0, ErrorKind::LimitExceeded("file bytes")));
}
let source =
std::str::from_utf8(bytes).map_err(|e| err(e.valid_up_to(), ErrorKind::InvalidUtf8))?;
let mut p = Parser {
source,
pos: if source.starts_with('\u{feff}') { 3 } else { 0 },
look: None,
limits,
budget: Budget::default(),
};
p.word("world")?;
p.symbol(b'(')?;
p.word("computedFeatures")?;
let computed = match p.next()? {
Token {
kind: Kind::Word("true"),
..
} => true,
Token {
kind: Kind::Word("false"),
..
} => false,
t => return Err(err(t.at, ErrorKind::Syntax("expected boolean"))),
};
let mut world = World {
computed,
..World::default()
};
if p.is(Kind::Word("stringProperties"))? {
p.next()?;
world.string_properties = p.names()?;
}
if p.is(Kind::Word("uvProperties"))? {
p.next()?;
world.uv_properties = p.names()?;
}
loop {
match p.peek()?.kind {
Kind::Word("brush") => {
let b = p.brush(&world)?;
p.push(&mut world.brushes, b)?;
}
Kind::Word("patch9") => {
let patch = p.patch(computed)?;
p.push(&mut world.patches, patch)?;
}
_ => break,
}
}
p.symbol(b')')?;
p.expect(Kind::End, "expected end of input")?;
Ok(world)
}