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>, limits: &'a Limits, budget: Budget, } impl<'a> Parser<'a> { fn lex(&mut self) -> Result> { 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> { if let Some(token) = self.look { return Ok(token); } let token = self.lex()?; self.look = Some(token); Ok(token) } fn next(&mut self) -> Result> { let token = self.peek()?; self.look = None; Ok(token) } fn is(&mut self, kind: Kind<'a>) -> Result { 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(&mut self, out: &mut Vec, value: T) -> Result<()> { self.budget.push(out, value, self.limits, self.pos) } fn string(&mut self) -> Result { 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 { 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::() .map_err(|_| err(token.at, ErrorKind::InvalidNumber))?; u32::try_from(n).map_err(|_| err(token.at, ErrorKind::InvalidNumber)) } fn float(&mut self) -> Result { let token = self.next()?; let Kind::Number(raw, _) = token.kind else { return Err(err(token.at, ErrorKind::Syntax("expected number"))); }; let n = raw .parse::() .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 { Ok([self.float()?, self.float()?, self.float()?]) } fn vectors(&mut self) -> Result> { 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> { 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( &mut self, key: &'static str, names: usize, mut value: impl FnMut(&mut Self) -> Result, ) -> Result>> { 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 { 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 { 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 { 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 { 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) }