actually compiles and does stuff now

src/parser/v3/nodes/asm_instr.rs

@@ -0,0 +1,82 @@
+use super::{PIdent, Node, Parsable, ParseResult, ParserCtx, ParserMsg, Symbol};
+
+pub struct PInstruction {
+    pub op: Node<PIdent>,
+    pub args: Vec<Node<PAsmArg>>,
+}
+
+pub enum PAsmArg {
+    Value(Node<PIdent>),
+    Ref(Node<PIdent>),
+}
+
+impl Parsable for PInstruction {
+    fn parse(ctx: &mut ParserCtx) -> ParseResult<Self> {
+        let op = ctx.parse()?;
+        let mut args = Vec::new();
+        if !ctx.next_on_new_line() {
+            let arg = ctx.parse()?;
+            args.push(arg);
+            loop {
+                if ctx.next_on_new_line() {
+                    break;
+                }
+                ctx.expect_sym(Symbol::Comma)?;
+                let arg = ctx.parse()?;
+                args.push(arg);
+            }
+        }
+        ParseResult::Ok(Self { op, args })
+    }
+}
+
+impl Parsable for PAsmArg {
+    fn parse(ctx: &mut ParserCtx) -> ParseResult<Self> {
+        if let Some(ident) = ctx.maybe_parse() {
+            return ParseResult::Ok(Self::Value(ident));
+        }
+
+        let next = ctx.expect_peek()?;
+        if !next.is_symbol(Symbol::OpenCurly) {
+            return ParseResult::Err(ParserMsg::unexpected_token(
+                next,
+                "An identifier or {identifier}",
+            ));
+        }
+        ctx.next();
+
+        let res = ctx.parse();
+        if res.recover {
+            ctx.seek_sym(Symbol::CloseCurly);
+            return ParseResult::SubErr;
+        }
+
+        ctx.expect_sym(Symbol::CloseCurly)?;
+        ParseResult::Ok(Self::Ref(res.node))
+    }
+}
+
+impl std::fmt::Debug for PAsmArg {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Value(v) => v.fmt(f),
+            Self::Ref(r) => write!(f, "{{{:?}}}", r),
+        }
+    }
+}
+
+impl std::fmt::Debug for PInstruction {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.op.fmt(f)?;
+        let mut iter = self.args.iter();
+        if let Some(arg) = iter.next() {
+            f.write_str(" ")?;
+            arg.fmt(f)?;
+        }
+        for arg in iter {
+            f.write_str(", ")?;
+            arg.fmt(f)?;
+        }
+        Ok(())
+    }
+}