Method parse_scene_inner

perro_source/runtime_project/perro_scene/src/parser.rs:536–755

(mut self)

        let name = self.expect_scene_key()?;
        self.expect(Token::RBracket)?;
        Ok(name)
    }

    fn skip_node_body(&mut self, key: &str) -> ParseResult<()> {
        loop {
            match self.current {
                Token::Eof => break,
                Token::LBracket => {
                    self.advance();
                    if self.current == Token::Slash {
                        let end = self.skip_closing_tag_after_lbracket()?;
                        if end.as_ref() == key {
                            break;
                        }
                    }
                }
                _ => self.advance(),
            }
        }
        Ok(())
    }

    pub(crate) fn parse_scene_inner(mut self) -> ParseResult<Scene> {
        let mut nodes = Vec::new();
        let mut root_name = None::<String>;
        let mut key_names = Vec::<Cow<'static, str>>::new();
        let mut key_ids = HashMap::<Cow<'a, str>, SceneKey>::new();
        let mut defined_keys = HashSet::<SceneKey>::new();
        let mut pending_parents = Vec::<(usize, String)>::new();

        while self.current != Token::Eof {
            match self.current {
                Token::Error(ref err) => return Err(err.to_string()),
                Token::Dollar => {
                    self.advance();
                    let name = self.expect_ident()?;
                    self.expect(Token::Equals)?;

                    if name == "root" {
                        match self.parse_value()? {
                            SceneValue::Key(k) => {
                                let key = k.to_string();
                                root_name = Some(key.clone());
                                self.vars.insert("root".to_string(), SceneValue::Key(k));
                            }
                            _ => return Err("root must be a node ref like @Main".to_string()),
                        }
                    } else {
                        let value = self.parse_value()?;
                        self.vars.insert(name.to_string(), value);
                    }
                }

                Token::At => {
                    return Err("use `$root = @NodeKey`; @ only marks node refs".to_string());
                }

                Token::LBracket => {