Method parse_multiplicative

crates/hll-to-ir/src/parser.rs:887–938

(&mut self)

                    } else {
                        ops.push(AsmOp::Raw(line.clone()));
                    }
                }
                ("la", [reg, operand]) if operand.starts_with('$') => {
                    let Some(place) = Self::parse_asm_place(operand) else {
                        return Err(self.error("invalid inline-asm `$place` operand"));
                    };
                    ops.push(AsmOp::Addr {
                        reg: (*reg).to_owned(),
                        place,
                    });
                }
                _ => ops.push(AsmOp::Raw(line)),
            }
        }
        Ok(ops)
    }

    fn parse_asm_place(operand: &str) -> Option<crate::ast::AsmPlace> {
        let path = operand.strip_prefix('$')?;
        let mut segments = path.split('.');
        let base = segments.next()?;
        if !Self::valid_asm_place_segment(base) {
            return None;
        }
        let fields = segments.map(str::to_owned).collect::<Vec<_>>();
        if fields
            .iter()
            .any(|field| !Self::valid_asm_place_segment(field))
        {
            return None;
        }
        Some(crate::ast::AsmPlace {
            base: base.to_owned(),
            fields,
        })
    }

    fn valid_asm_place_segment(segment: &str) -> bool {
        let mut chars = segment.chars();
        chars
            .next()
            .is_some_and(|ch| ch == '_' || ch.is_ascii_alphabetic())
            && chars.all(|ch| ch == '_' || ch.is_ascii_alphanumeric())
    }

    fn parse_assignment(&mut self) -> Result<Expression, ParserError> {
        if matches!(self.peek(), Some(Token::LBrace)) {
            let saved_pos = self.pos;
            let mut trial = self.clone();

            if let Ok(target) = trial.parse_struct_destructure_target()
                && trial.match_assign()
            {
                *self = trial;
                let rvalue = self.parse_assignment()?;