From 9c8dd4d8827b642a905751619cee90bc71d9e321 Mon Sep 17 00:00:00 2001 From: Nathan Vegdahl Date: Sun, 5 Jan 2020 23:07:26 +0900 Subject: [PATCH] Initial just-get-it-working port of scene paring code to streaming data tree. It doesn't actually stream yet, just loads the whole parse into memory, but done via the new streaming code. --- src/parse/data_tree.rs | 684 +++++++++-------------------------------- src/parse/psy.rs | 57 ++-- src/parse/psy_light.rs | 34 +- 3 files changed, 193 insertions(+), 582 deletions(-) diff --git a/src/parse/data_tree.rs b/src/parse/data_tree.rs index e43b357..bd02226 100644 --- a/src/parse/data_tree.rs +++ b/src/parse/data_tree.rs @@ -1,92 +1,131 @@ #![allow(dead_code)] -use std::{iter::Iterator, result::Result, slice}; +use std::{io::Cursor, iter::Iterator, result::Result, slice}; + +use data_tree::{Event, Parser}; #[derive(Debug, Eq, PartialEq)] -pub enum DataTree<'a> { +pub enum DataTree { Internal { - type_name: &'a str, - ident: Option<&'a str>, - children: Vec>, + type_name: String, + ident: Option, + children: Vec, byte_offset: usize, }, Leaf { - type_name: &'a str, - contents: &'a str, + type_name: String, + contents: String, byte_offset: usize, }, } -impl<'a> DataTree<'a> { - pub fn from_str(source_text: &'a str) -> Result, ParseError> { +#[derive(Copy, Clone, Eq, PartialEq, Debug)] +pub enum ParseError { + Other(&'static str), +} + +// #[derive(Copy, Clone, Eq, PartialEq, Debug)] +// pub enum ParseError { +// MissingOpener(usize), +// MissingOpenInternal(usize), +// MissingCloseInternal(usize), +// MissingOpenLeaf(usize), +// MissingCloseLeaf(usize), +// MissingTypeName(usize), +// UnexpectedIdent(usize), +// UnknownToken(usize), +// Other((usize, &'static str)), +// } + +impl<'a> DataTree { + pub fn from_str(source_text: &'a str) -> Result { + let mut parser = Parser::new(Cursor::new(source_text)); let mut items = Vec::new(); - let mut remaining_text = (0, source_text); - while let Some((item, text)) = parse_node(remaining_text)? { - remaining_text = text; - items.push(item); + loop { + let event = parser.next_event(); + println!("{:?}", event); + match event { + Ok(Event::InnerOpen { + type_name, + ident, + byte_offset, + }) => { + let type_name = type_name.into(); + let ident = ident.map(|id| id.into()); + items.push(parse_node(&mut parser, type_name, ident, byte_offset)?); + } + Ok(Event::Leaf { + type_name, + contents, + byte_offset, + }) => return Err(ParseError::Other("Unexpected leaf value at root level.")), + Ok(Event::InnerClose { .. }) => { + return Err(ParseError::Other("Unexpected closing tag.")) + } + Ok(Event::Done) => { + break; + } + + Err(_) => return Err(ParseError::Other("Some error happened.")), + } } - remaining_text = skip_ws_and_comments(remaining_text); - - if remaining_text.1.is_empty() { - return Ok(DataTree::Internal { - type_name: "ROOT", - ident: None, - children: items, - byte_offset: 0, - }); - } else { - // If the whole text wasn't parsed, something went wrong. - return Err(ParseError::Other((0, "Failed to parse the entire string."))); - } + return Ok(DataTree::Internal { + type_name: "ROOT".into(), + ident: None, + children: items, + byte_offset: 0, + }); } pub fn type_name(&'a self) -> &'a str { - match *self { + match self { DataTree::Internal { type_name, .. } | DataTree::Leaf { type_name, .. } => type_name, } } pub fn ident(&'a self) -> Option<&'a str> { - match *self { - DataTree::Internal { ident, .. } => ident, - DataTree::Leaf { .. } => None, + match self { + DataTree::Internal { + ident: Some(id), .. + } => Some(id.as_str()), + _ => None, } } pub fn byte_offset(&'a self) -> usize { - match *self { + match self { DataTree::Internal { byte_offset, .. } | DataTree::Leaf { byte_offset, .. } => { - byte_offset + *byte_offset } } } pub fn is_internal(&self) -> bool { - match *self { + match self { DataTree::Internal { .. } => true, DataTree::Leaf { .. } => false, } } pub fn is_leaf(&self) -> bool { - match *self { + match self { DataTree::Internal { .. } => false, DataTree::Leaf { .. } => true, } } pub fn leaf_contents(&'a self) -> Option<&'a str> { - match *self { + match self { DataTree::Internal { .. } => None, - DataTree::Leaf { contents, .. } => Some(contents), + DataTree::Leaf { contents, .. } => Some(contents.as_str()), } } - pub fn iter_children(&'a self) -> slice::Iter<'a, DataTree<'a>> { - if let DataTree::Internal { ref children, .. } = *self { + pub fn iter_children(&'a self) -> slice::Iter<'a, DataTree> { + if let DataTree::Internal { ref children, .. } = self { children.iter() } else { [].iter() @@ -94,7 +133,7 @@ impl<'a> DataTree<'a> { } pub fn iter_children_with_type(&'a self, type_name: &'static str) -> DataTreeFilterIter<'a> { - if let DataTree::Internal { ref children, .. } = *self { + if let DataTree::Internal { ref children, .. } = self { DataTreeFilterIter { type_name: type_name, iter: children.iter(), @@ -142,15 +181,15 @@ impl<'a> DataTree<'a> { } // For unit tests - fn internal_data_or_panic(&'a self) -> (&'a str, Option<&'a str>, &'a Vec>) { + fn internal_data_or_panic(&'a self) -> (&'a str, Option<&'a str>, &'a Vec) { if let DataTree::Internal { type_name, - ident, + ref ident, ref children, .. - } = *self + } = self { - (type_name, ident, children) + (type_name, ident.as_ref().map(|id| id.as_str()), children) } else { panic!("Expected DataTree::Internal, found DataTree::Leaf") } @@ -160,7 +199,7 @@ impl<'a> DataTree<'a> { type_name, contents, .. - } = *self + } = self { (type_name, contents) } else { @@ -169,17 +208,64 @@ impl<'a> DataTree<'a> { } } +fn parse_node( + parser: &mut Parser, + type_name: String, + ident: Option, + byte_offset: usize, +) -> Result { + let mut children = Vec::new(); + loop { + match parser.next_event() { + Ok(Event::InnerOpen { + type_name, + ident, + byte_offset, + }) => { + let type_name = type_name.into(); + let ident = ident.map(|id| id.into()); + children.push(parse_node(parser, type_name, ident, byte_offset)?); + } + Ok(Event::Leaf { + type_name, + contents, + byte_offset, + }) => { + children.push(DataTree::Leaf { + type_name: type_name.into(), + contents: contents.into(), + byte_offset: byte_offset, + }); + } + Ok(Event::InnerClose { .. }) => break, + Ok(Event::Done) => { + return Err(ParseError::Other("Unexpected end of contents.")); + } + Err(_) => { + return Err(ParseError::Other("Some error happened.")); + } + } + } + + Ok(DataTree::Internal { + type_name: type_name, + ident: ident, + children: children, + byte_offset: byte_offset, + }) +} + /// An iterator over the children of a `DataTree` node that filters out the /// children not matching a specified type name. pub struct DataTreeFilterIter<'a> { type_name: &'a str, - iter: slice::Iter<'a, DataTree<'a>>, + iter: slice::Iter<'a, DataTree>, } impl<'a> Iterator for DataTreeFilterIter<'a> { - type Item = &'a DataTree<'a>; + type Item = &'a DataTree; - fn next(&mut self) -> Option<&'a DataTree<'a>> { + fn next(&mut self) -> Option<&'a DataTree> { loop { if let Some(dt) = self.iter.next() { if dt.type_name() == self.type_name { @@ -199,29 +285,34 @@ impl<'a> Iterator for DataTreeFilterIter<'a> { /// type name. pub struct DataTreeFilterInternalIter<'a> { type_name: &'a str, - iter: slice::Iter<'a, DataTree<'a>>, + iter: slice::Iter<'a, DataTree>, } impl<'a> Iterator for DataTreeFilterInternalIter<'a> { - type Item = (&'a str, Option<&'a str>, &'a Vec>, usize); + type Item = (&'a str, Option<&'a str>, &'a Vec, usize); - fn next(&mut self) -> Option<(&'a str, Option<&'a str>, &'a Vec>, usize)> { + fn next(&mut self) -> Option<(&'a str, Option<&'a str>, &'a Vec, usize)> { loop { match self.iter.next() { - Some(&DataTree::Internal { + Some(DataTree::Internal { type_name, ident, - ref children, + children, byte_offset, }) => { if type_name == self.type_name { - return Some((type_name, ident, children, byte_offset)); + return Some(( + type_name, + ident.as_ref().map(|id| id.as_str()), + children, + *byte_offset, + )); } else { continue; } } - Some(&DataTree::Leaf { .. }) => { + Some(DataTree::Leaf { .. }) => { continue; } @@ -238,7 +329,7 @@ impl<'a> Iterator for DataTreeFilterInternalIter<'a> { /// type name. pub struct DataTreeFilterLeafIter<'a> { type_name: &'a str, - iter: slice::Iter<'a, DataTree<'a>>, + iter: slice::Iter<'a, DataTree>, } impl<'a> Iterator for DataTreeFilterLeafIter<'a> { @@ -247,17 +338,17 @@ impl<'a> Iterator for DataTreeFilterLeafIter<'a> { fn next(&mut self) -> Option<(&'a str, &'a str, usize)> { loop { match self.iter.next() { - Some(&DataTree::Internal { .. }) => { + Some(DataTree::Internal { .. }) => { continue; } - Some(&DataTree::Leaf { + Some(DataTree::Leaf { type_name, contents, byte_offset, }) => { if type_name == self.type_name { - return Some((type_name, contents, byte_offset)); + return Some((type_name, contents, *byte_offset)); } else { continue; } @@ -270,480 +361,3 @@ impl<'a> Iterator for DataTreeFilterLeafIter<'a> { } } } - -#[derive(Copy, Clone, Eq, PartialEq, Debug)] -pub enum ParseError { - MissingOpener(usize), - MissingOpenInternal(usize), - MissingCloseInternal(usize), - MissingOpenLeaf(usize), - MissingCloseLeaf(usize), - MissingTypeName(usize), - UnexpectedIdent(usize), - UnknownToken(usize), - Other((usize, &'static str)), -} - -// ================================================================ - -#[derive(Debug, PartialEq, Eq)] -enum Token<'a> { - OpenInner, - CloseInner, - OpenLeaf, - CloseLeaf, - TypeName(&'a str), - Ident(&'a str), - End, - Unknown, -} - -type ParseResult<'a> = Result, (usize, &'a str))>, ParseError>; - -fn parse_node<'a>(source_text: (usize, &'a str)) -> ParseResult<'a> { - let (token, text1) = next_token(source_text); - if let Token::TypeName(type_name) = token { - match next_token(text1) { - // Internal with name - (Token::Ident(n), text2) => { - if let (Token::OpenInner, text3) = next_token(text2) { - let mut children = Vec::new(); - let mut text_remaining = text3; - while let Some((node, text4)) = parse_node(text_remaining)? { - text_remaining = text4; - children.push(node); - } - if let (Token::CloseInner, text4) = next_token(text_remaining) { - return Ok(Some(( - DataTree::Internal { - type_name: type_name, - ident: Some(n), - children: children, - byte_offset: text1.0, - }, - text4, - ))); - } else { - return Err(ParseError::MissingCloseInternal(text_remaining.0)); - } - } else { - return Err(ParseError::MissingOpenInternal(text2.0)); - } - } - - // Internal without name - (Token::OpenInner, text2) => { - let mut children = Vec::new(); - let mut text_remaining = text2; - while let Some((node, text3)) = parse_node(text_remaining)? { - text_remaining = text3; - children.push(node); - } - - if let (Token::CloseInner, text3) = next_token(text_remaining) { - return Ok(Some(( - DataTree::Internal { - type_name: type_name, - ident: None, - children: children, - byte_offset: text1.0, - }, - text3, - ))); - } else { - return Err(ParseError::MissingCloseInternal(text_remaining.0)); - } - } - - // Leaf - (Token::OpenLeaf, text2) => { - let (contents, text3) = parse_leaf_content(text2); - if let (Token::CloseLeaf, text4) = next_token(text3) { - return Ok(Some(( - DataTree::Leaf { - type_name: type_name, - contents: contents, - byte_offset: text1.0, - }, - text4, - ))); - } else { - return Err(ParseError::MissingCloseLeaf(text3.0)); - } - } - - // Other - _ => { - return Err(ParseError::MissingOpener(text1.0)); - } - } - } else { - return Ok(None); - } -} - -fn parse_leaf_content(source_text: (usize, &str)) -> (&str, (usize, &str)) { - let mut si = 1; - let mut escaped = false; - let mut reached_end = true; - for (i, c) in source_text.1.char_indices() { - si = i; - if escaped { - escaped = false; - } else if c == '\\' { - escaped = true; - } else if c == ']' { - reached_end = false; - break; - } - } - - if reached_end { - si = source_text.1.len(); - } - - return ( - &source_text.1[0..si], - (source_text.0 + si, &source_text.1[si..]), - ); -} - -fn next_token<'a>(source_text: (usize, &'a str)) -> (Token<'a>, (usize, &'a str)) { - let text1 = skip_ws_and_comments(source_text); - - if let Some(c) = text1.1.chars().nth(0) { - let text2 = (text1.0 + c.len_utf8(), &text1.1[c.len_utf8()..]); - match c { - '{' => { - return (Token::OpenInner, text2); - } - - '}' => { - return (Token::CloseInner, text2); - } - - '[' => { - return (Token::OpenLeaf, text2); - } - - ']' => { - return (Token::CloseLeaf, text2); - } - - '$' => { - // Parse name - let mut si = 1; - let mut escaped = false; - let mut reached_end = true; - for (i, c) in text1.1.char_indices().skip(1) { - si = i; - if escaped { - escaped = false; - } else if c == '\\' { - escaped = true; - } else if !is_ident_char(c) { - reached_end = false; - break; - } - } - - if reached_end { - si = text1.1.len(); - } - - return ( - Token::Ident(&text1.1[0..si]), - (text1.0 + si, &text1.1[si..]), - ); - } - - _ => { - if is_ident_char(c) { - // Parse type - let mut si = 0; - let mut reached_end = true; - for (i, c) in text1.1.char_indices() { - si = i; - if !is_ident_char(c) { - reached_end = false; - break; - } - } - - if reached_end { - si = text1.1.len(); - } - - return ( - Token::TypeName(&text1.1[0..si]), - (text1.0 + si, &text1.1[si..]), - ); - } - } - } - } else { - return (Token::End, text1); - } - - return (Token::Unknown, text1); -} - -fn is_ws(c: char) -> bool { - match c { - '\n' | '\r' | '\t' | ' ' => true, - _ => false, - } -} - -fn is_nl(c: char) -> bool { - match c { - '\n' | '\r' => true, - _ => false, - } -} - -fn is_reserved_char(c: char) -> bool { - match c { - '{' | '}' | '[' | ']' | '$' | '#' | '\\' => true, - _ => false, - } -} - -fn is_ident_char(c: char) -> bool { - // Anything that isn't whitespace or a reserved character - !is_ws(c) && !is_reserved_char(c) -} - -fn skip_ws(text: &str) -> &str { - let mut si = 0; - let mut reached_end = true; - for (i, c) in text.char_indices() { - si = i; - if !is_ws(c) { - reached_end = false; - break; - } - } - - if reached_end { - si = text.len(); - } - - return &text[si..]; -} - -fn skip_comment(text: &str) -> &str { - let mut si = 0; - if Some('#') == text.chars().nth(0) { - let mut reached_end = true; - for (i, c) in text.char_indices() { - si = i; - if is_nl(c) { - reached_end = false; - break; - } - } - - if reached_end { - si = text.len(); - } - } - - return &text[si..]; -} - -fn skip_ws_and_comments(text: (usize, &str)) -> (usize, &str) { - let mut remaining_text = text.1; - - loop { - let tmp = skip_comment(skip_ws(remaining_text)); - - if tmp.len() == remaining_text.len() { - break; - } else { - remaining_text = tmp; - } - } - - let offset = text.0 + text.1.len() - remaining_text.len(); - return (offset, remaining_text); -} - -// ================================================================ - -#[cfg(test)] -mod tests { - use super::*; - use super::{next_token, Token}; - - #[test] - fn tokenize_1() { - let input = (0, "Thing"); - - assert_eq!(next_token(input), (Token::TypeName("Thing"), (5, ""))); - } - - #[test] - fn tokenize_2() { - let input = (0, " \n# gdfgdf gfdg dggdf\\sg dfgsd \n Thing"); - - assert_eq!(next_token(input), (Token::TypeName("Thing"), (41, ""))); - } - - #[test] - fn tokenize_3() { - let input1 = (0, " Thing { }"); - let (token1, input2) = next_token(input1); - let (token2, input3) = next_token(input2); - let (token3, input4) = next_token(input3); - - assert_eq!((token1, input2.1), (Token::TypeName("Thing"), " { }")); - assert_eq!((token2, input3.1), (Token::OpenInner, " }")); - assert_eq!((token3, input4.1), (Token::CloseInner, "")); - } - - #[test] - fn tokenize_4() { - let input = (0, " $hi_there "); - - assert_eq!(next_token(input), (Token::Ident("$hi_there"), (10, " "))); - } - - #[test] - fn tokenize_5() { - let input = (0, " $hi\\ t\\#he\\[re "); - - assert_eq!( - next_token(input), - (Token::Ident("$hi\\ t\\#he\\[re"), (15, " "),) - ); - } - - #[test] - fn tokenize_6() { - let input1 = (0, " $hi the[re"); - let (token1, input2) = next_token(input1); - let (token2, input3) = next_token(input2); - let (token3, input4) = next_token(input3); - let (token4, input5) = next_token(input4); - let (token5, input6) = next_token(input5); - - assert_eq!((token1, input2), (Token::Ident("$hi"), (4, " the[re"))); - assert_eq!((token2, input3), (Token::TypeName("the"), (8, "[re"))); - assert_eq!((token3, input4), (Token::OpenLeaf, (9, "re"))); - assert_eq!((token4, input5), (Token::TypeName("re"), (11, ""))); - assert_eq!((token5, input6), (Token::End, (11, ""))); - } - - #[test] - fn tokenize_7() { - let input1 = (0, "Thing $yar { # A comment\n\tThing2 []\n}"); - let (token1, input2) = next_token(input1); - let (token2, input3) = next_token(input2); - let (token3, input4) = next_token(input3); - let (token4, input5) = next_token(input4); - let (token5, input6) = next_token(input5); - let (token6, input7) = next_token(input6); - let (token7, input8) = next_token(input7); - let (token8, input9) = next_token(input8); - - assert_eq!( - (token1, input2), - ( - Token::TypeName("Thing"), - (5, " $yar { # A comment\n\tThing2 []\n}",) - ) - ); - assert_eq!( - (token2, input3), - ( - Token::Ident("$yar"), - (10, " { # A comment\n\tThing2 []\n}",) - ) - ); - assert_eq!( - (token3, input4), - (Token::OpenInner, (12, " # A comment\n\tThing2 []\n}",)) - ); - assert_eq!( - (token4, input5), - (Token::TypeName("Thing2"), (32, " []\n}")) - ); - assert_eq!((token5, input6), (Token::OpenLeaf, (34, "]\n}"))); - assert_eq!((token6, input7), (Token::CloseLeaf, (35, "\n}"))); - assert_eq!((token7, input8), (Token::CloseInner, (37, ""))); - assert_eq!((token8, input9), (Token::End, (37, ""))); - } - - #[test] - fn parse_1() { - let input = r#" - Thing {} - "#; - - let dt = DataTree::from_str(input).unwrap(); - - // Root - let (t, i, c) = dt.internal_data_or_panic(); - assert_eq!(t, "ROOT"); - assert_eq!(i, None); - assert_eq!(c.len(), 1); - - // First (and only) child - let (t, i, c) = c[0].internal_data_or_panic(); - assert_eq!(t, "Thing"); - assert_eq!(i, None); - assert_eq!(c.len(), 0); - } - - #[test] - fn iter_1() { - let dt = DataTree::from_str( - r#" - A {} - B {} - A [] - A {} - B {} - "#, - ) - .unwrap(); - - let i = dt.iter_children_with_type("A"); - assert_eq!(i.count(), 3); - } - - #[test] - fn iter_2() { - let dt = DataTree::from_str( - r#" - A {} - B {} - A [] - A {} - B {} - "#, - ) - .unwrap(); - - let i = dt.iter_internal_children_with_type("A"); - assert_eq!(i.count(), 2); - } - - #[test] - fn iter_3() { - let dt = DataTree::from_str( - r#" - A [] - B {} - A {} - A [] - B {} - "#, - ) - .unwrap(); - - let i = dt.iter_leaf_children_with_type("A"); - assert_eq!(i.count(), 2); - } -} diff --git a/src/parse/psy.rs b/src/parse/psy.rs index 5ef9907..e681a0b 100644 --- a/src/parse/psy.rs +++ b/src/parse/psy.rs @@ -100,10 +100,7 @@ fn line_count_to_byte_offset(text: &str, offset: usize) -> usize { } /// Takes in a `DataTree` representing a Scene node and returns -pub fn parse_scene<'a>( - arena: &'a Arena, - tree: &'a DataTree, -) -> Result, PsyParseError> { +pub fn parse_scene<'a>(arena: &'a Arena, tree: &'a DataTree) -> Result, PsyParseError> { // Verify we have the right number of each section if tree.iter_children_with_type("Output").count() != 1 { let count = tree.iter_children_with_type("Output").count(); @@ -187,9 +184,9 @@ pub fn parse_scene<'a>( )?; // Put scene together - let scene_name = if let DataTree::Internal { ident, .. } = *tree { + let scene_name = if let DataTree::Internal { ident, .. } = tree { if let Some(name) = ident { - Some(name.to_string()) + Some(name.clone()) } else { None } @@ -224,7 +221,7 @@ fn parse_output_info(tree: &DataTree) -> Result { let mut path = String::new(); for child in children { - match *child { + match child { DataTree::Leaf { type_name, contents, @@ -234,14 +231,14 @@ fn parse_output_info(tree: &DataTree) -> Result { let tc = contents.trim(); if tc.chars().count() < 2 { return Err(PsyParseError::IncorrectLeafData( - byte_offset, + *byte_offset, "File path format is \ incorrect.", )); } if tc.chars().nth(0).unwrap() != '"' || !tc.ends_with('"') { return Err(PsyParseError::IncorrectLeafData( - byte_offset, + *byte_offset, "File paths must be \ surrounded by quotes.", )); @@ -285,7 +282,7 @@ fn parse_render_settings(tree: &DataTree) -> Result<((u32, u32), u32, u32), PsyP let mut seed = 0; for child in children { - match *child { + match child { // Resolution DataTree::Leaf { type_name, @@ -293,14 +290,14 @@ fn parse_render_settings(tree: &DataTree) -> Result<((u32, u32), u32, u32), PsyP byte_offset, } if type_name == "Resolution" => { if let IResult::Ok((_, (w, h))) = - all_consuming(tuple((ws_u32, ws_u32)))(contents) + all_consuming(tuple((ws_u32, ws_u32)))(&contents) { found_res = true; res = (w, h); } else { // Found Resolution, but its contents is not in the right format return Err(PsyParseError::IncorrectLeafData( - byte_offset, + *byte_offset, "Resolution should be specified with two \ integers in the form '[width height]'.", )); @@ -313,13 +310,13 @@ fn parse_render_settings(tree: &DataTree) -> Result<((u32, u32), u32, u32), PsyP contents, byte_offset, } if type_name == "SamplesPerPixel" => { - if let IResult::Ok((_, n)) = all_consuming(ws_u32)(contents) { + if let IResult::Ok((_, n)) = all_consuming(ws_u32)(&contents) { found_spp = true; spp = n; } else { // Found SamplesPerPixel, but its contents is not in the right format return Err(PsyParseError::IncorrectLeafData( - byte_offset, + *byte_offset, "SamplesPerPixel should be \ an integer specified in \ the form '[samples]'.", @@ -333,12 +330,12 @@ fn parse_render_settings(tree: &DataTree) -> Result<((u32, u32), u32, u32), PsyP contents, byte_offset, } if type_name == "Seed" => { - if let IResult::Ok((_, n)) = all_consuming(ws_u32)(contents) { + if let IResult::Ok((_, n)) = all_consuming(ws_u32)(&contents) { seed = n; } else { // Found Seed, but its contents is not in the right format return Err(PsyParseError::IncorrectLeafData( - byte_offset, + *byte_offset, "Seed should be an integer \ specified in the form \ '[samples]'.", @@ -378,19 +375,19 @@ fn parse_camera<'a>(arena: &'a Arena, tree: &'a DataTree) -> Result, // Parse for child in children.iter() { - match *child { + match child { // Fov DataTree::Leaf { type_name, contents, byte_offset, } if type_name == "Fov" => { - if let IResult::Ok((_, fov)) = all_consuming(ws_f32)(contents) { + if let IResult::Ok((_, fov)) = all_consuming(ws_f32)(&contents) { fovs.push(fov * (f32::consts::PI / 180.0)); } else { // Found Fov, but its contents is not in the right format return Err(PsyParseError::IncorrectLeafData( - byte_offset, + *byte_offset, "Fov should be a decimal \ number specified in the \ form '[fov]'.", @@ -404,12 +401,12 @@ fn parse_camera<'a>(arena: &'a Arena, tree: &'a DataTree) -> Result, contents, byte_offset, } if type_name == "FocalDistance" => { - if let IResult::Ok((_, fd)) = all_consuming(ws_f32)(contents) { + if let IResult::Ok((_, fd)) = all_consuming(ws_f32)(&contents) { focus_distances.push(fd); } else { // Found FocalDistance, but its contents is not in the right format return Err(PsyParseError::IncorrectLeafData( - byte_offset, + *byte_offset, "FocalDistance should be a \ decimal number specified \ in the form '[fov]'.", @@ -423,12 +420,12 @@ fn parse_camera<'a>(arena: &'a Arena, tree: &'a DataTree) -> Result, contents, byte_offset, } if type_name == "ApertureRadius" => { - if let IResult::Ok((_, ar)) = all_consuming(ws_f32)(contents) { + if let IResult::Ok((_, ar)) = all_consuming(ws_f32)(&contents) { aperture_radii.push(ar); } else { // Found ApertureRadius, but its contents is not in the right format return Err(PsyParseError::IncorrectLeafData( - byte_offset, + *byte_offset, "ApertureRadius should be a \ decimal number specified \ in the form '[fov]'.", @@ -442,11 +439,11 @@ fn parse_camera<'a>(arena: &'a Arena, tree: &'a DataTree) -> Result, contents, byte_offset, } if type_name == "Transform" => { - if let Ok(mat) = parse_matrix(contents) { + if let Ok(mat) = parse_matrix(&contents) { mats.push(mat); } else { // Found Transform, but its contents is not in the right format - return Err(make_transform_format_error(byte_offset)); + return Err(make_transform_format_error(*byte_offset)); } } @@ -499,7 +496,7 @@ fn parse_world<'a>(arena: &'a Arena, tree: &'a DataTree) -> Result, Ps )); } if let DataTree::Leaf { contents, .. } = - *bgs.iter_children_with_type("Type").nth(0).unwrap() + bgs.iter_children_with_type("Type").nth(0).unwrap() { contents.trim() } else { @@ -512,17 +509,17 @@ fn parse_world<'a>(arena: &'a Arena, tree: &'a DataTree) -> Result, Ps }; match bgs_type { "Color" => { - if let Some(&DataTree::Leaf { + if let Some(DataTree::Leaf { contents, byte_offset, .. }) = bgs.iter_children_with_type("Color").nth(0) { - if let Ok(color) = parse_color(contents) { + if let Ok(color) = parse_color(&contents) { background_color = color; } else { return Err(PsyParseError::IncorrectLeafData( - byte_offset, + *byte_offset, "Color should be specified \ with three decimal numbers \ in the form '[R G B]'.", @@ -548,7 +545,7 @@ fn parse_world<'a>(arena: &'a Arena, tree: &'a DataTree) -> Result, Ps // Parse light sources for child in tree.iter_children() { - match *child { + match child { DataTree::Internal { type_name, .. } if type_name == "DistantDiskLight" => { lights.push(arena.alloc(parse_distant_disk_light(arena, child)?)); } diff --git a/src/parse/psy_light.rs b/src/parse/psy_light.rs index 12e7fac..df59820 100644 --- a/src/parse/psy_light.rs +++ b/src/parse/psy_light.rs @@ -28,18 +28,18 @@ pub fn parse_distant_disk_light<'a>( // Parse for child in children.iter() { - match *child { + match child { // Radius DataTree::Leaf { type_name, contents, byte_offset, } if type_name == "Radius" => { - if let IResult::Ok((_, radius)) = all_consuming(ws_f32)(contents) { + if let IResult::Ok((_, radius)) = all_consuming(ws_f32)(&contents) { radii.push(radius); } else { // Found radius, but its contents is not in the right format - return Err(PsyParseError::UnknownError(byte_offset)); + return Err(PsyParseError::UnknownError(*byte_offset)); } } @@ -50,12 +50,12 @@ pub fn parse_distant_disk_light<'a>( byte_offset, } if type_name == "Direction" => { if let IResult::Ok((_, direction)) = - all_consuming(tuple((ws_f32, ws_f32, ws_f32)))(contents) + all_consuming(tuple((ws_f32, ws_f32, ws_f32)))(&contents) { directions.push(Vector::new(direction.0, direction.1, direction.2)); } else { // Found direction, but its contents is not in the right format - return Err(PsyParseError::UnknownError(byte_offset)); + return Err(PsyParseError::UnknownError(*byte_offset)); } } @@ -65,11 +65,11 @@ pub fn parse_distant_disk_light<'a>( contents, byte_offset, } if type_name == "Color" => { - if let Ok(color) = parse_color(contents) { + if let Ok(color) = parse_color(&contents) { colors.push(color); } else { // Found color, but its contents is not in the right format - return Err(PsyParseError::UnknownError(byte_offset)); + return Err(PsyParseError::UnknownError(*byte_offset)); } } @@ -93,18 +93,18 @@ pub fn parse_sphere_light<'a>( // Parse for child in children.iter() { - match *child { + match child { // Radius DataTree::Leaf { type_name, contents, byte_offset, } if type_name == "Radius" => { - if let IResult::Ok((_, radius)) = all_consuming(ws_f32)(contents) { + if let IResult::Ok((_, radius)) = all_consuming(ws_f32)(&contents) { radii.push(radius); } else { // Found radius, but its contents is not in the right format - return Err(PsyParseError::UnknownError(byte_offset)); + return Err(PsyParseError::UnknownError(*byte_offset)); } } @@ -114,11 +114,11 @@ pub fn parse_sphere_light<'a>( contents, byte_offset, } if type_name == "Color" => { - if let Ok(color) = parse_color(contents) { + if let Ok(color) = parse_color(&contents) { colors.push(color); } else { // Found color, but its contents is not in the right format - return Err(PsyParseError::UnknownError(byte_offset)); + return Err(PsyParseError::UnknownError(*byte_offset)); } } @@ -142,7 +142,7 @@ pub fn parse_rectangle_light<'a>( // Parse for child in children.iter() { - match *child { + match child { // Dimensions DataTree::Leaf { type_name, @@ -150,12 +150,12 @@ pub fn parse_rectangle_light<'a>( byte_offset, } if type_name == "Dimensions" => { if let IResult::Ok((_, radius)) = - all_consuming(tuple((ws_f32, ws_f32)))(contents) + all_consuming(tuple((ws_f32, ws_f32)))(&contents) { dimensions.push(radius); } else { // Found dimensions, but its contents is not in the right format - return Err(PsyParseError::UnknownError(byte_offset)); + return Err(PsyParseError::UnknownError(*byte_offset)); } } @@ -165,11 +165,11 @@ pub fn parse_rectangle_light<'a>( contents, byte_offset, } if type_name == "Color" => { - if let Ok(color) = parse_color(contents) { + if let Ok(color) = parse_color(&contents) { colors.push(color); } else { // Found color, but its contents is not in the right format - return Err(PsyParseError::UnknownError(byte_offset)); + return Err(PsyParseError::UnknownError(*byte_offset)); } }