Download crates/mb3-txt/src/parser.rs from nmarshall/nanobrush: direct link, hf CLI and curl.
- Browser
- Download file 16.1 kB
-
https://huggingface.co/nmarshall/nanobrush/resolve/main/crates/mb3-txt/src/parser.rs
- Command line
-
hf download hf://nmarshall/nanobrush/crates/mb3-txt/src/parser.rs
-
curl -L -o parser.rs https://huggingface.co/nmarshall/nanobrush/resolve/main/crates/mb3-txt/src/parser.rs
16.1 kB
| use super::*; | |
| use mb3_dat::{Brush, Patch9, PatchComputed, Plane, Property, Uv, Vec3, World}; | |
| enum Kind<'a> { | |
| Word(&'a str), | |
| Number(&'a str, bool), | |
| Str(&'a str), | |
| Symbol(u8), | |
| End, | |
| } | |
| 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) | |
| } | |