wip

src/asm/decls/macros.rs

@@ -0,0 +1,34 @@
+use crate::*;
+
+
+pub fn collect(
+    report: &mut diagn::Report,
+    ast: &mut asm::AstTopLevel,
+    decls: &mut asm::ItemDecls)
+    -> Result<(), ()>
+{
+    for any_node in &mut ast.nodes
+    {
+        let asm::AstAny::DirectiveMacro(ref mut node) = any_node
+            else { continue };
+
+        if node.item_ref.is_some()
+        {
+            continue;
+        }
+
+
+        let item_ref = decls.ruledefs.declare(
+            report,
+            node.header_span,
+            &util::SymbolContext::new_global(),
+            decls.ruledefs.generate_anonymous_name(),
+            0,
+            util::SymbolKind::Other)?;
+
+        node.item_ref = Some(item_ref);
+    }
+
+
+    Ok(())
+}

src/asm/decls/mod.rs

@@ -4,6 +4,7 @@ use crate::*;
 mod bank;
 mod bankdef;
 mod ruledef;
+mod macros;
 mod symbol;
 mod function;
 
@@ -50,6 +51,7 @@ pub fn collect(
     bankdef::collect(report, ast, decls)?;
     bank::collect(report, ast, decls)?;
     ruledef::collect(report, ast, decls)?;
+    macros::collect(report, ast, decls)?;
     symbol::collect(report, ast, decls)?;
     function::collect(report, ast, decls)?;
 

src/asm/defs/ruledef.rs

@@ -106,7 +106,7 @@ pub fn resolve_rule(
     let mut exact_parts = 0;
     let mut parameters = Vec::<RuleParameter>::new();
 
-    for ast_part in &ast_rule.pattern
+    for ast_part in &ast_rule.pattern.parts
     {
         let part = {
             match &ast_part
@@ -137,7 +137,7 @@ pub fn resolve_rule(
     }
 
     Ok(Rule {
-        pattern_span: ast_rule.pattern_span,
+        pattern_span: ast_rule.pattern.span,
         pattern,
         exact_part_count: exact_parts,
         parameters,

src/asm/parser/directive.rs

@@ -81,6 +81,9 @@ pub fn parse(
         "subruledef" => Ok(asm::AstAny::DirectiveRuledef(
             asm::parser::directive_ruledef::parse(report, walker, true, header_span)?)),
 
+        "macro" => Ok(asm::AstAny::DirectiveMacro(
+            asm::parser::directive_ruledef::parse_macro(report, walker, header_span)?)),
+
         "assert" => Ok(asm::AstAny::DirectiveAssert(
             asm::parser::directive_assert::parse(report, walker, header_span)?)),
 

src/asm/parser/directive_if.rs

@@ -20,7 +20,7 @@ pub fn parse(
 {
     let expr = expr::parse(report, walker)?;
 
-    let true_arm = parse_braced_block(report, walker)?;
+    let true_arm = asm::parser::parse_braced_toplevel(report, walker)?;
     let false_arm = parse_else_blocks(report, walker)?;
 
     Ok(AstDirectiveIf {
@@ -33,23 +33,6 @@ pub fn parse(
 }
 
 
-fn parse_braced_block(
-    report: &mut diagn::Report,
-    walker: &mut syntax::Walker)
-    -> Result<asm::AstTopLevel, ()>
-{
-    walker.expect(report, syntax::TokenKind::BraceOpen)?;
-
-    let block = asm::parser::parse_nested_toplevel(
-        report,
-        walker)?;
-
-    walker.expect(report, syntax::TokenKind::BraceClose)?;
-
-    Ok(block)
-}
-
-
 fn parse_else_blocks(
     report: &mut diagn::Report,
     walker: &mut syntax::Walker)
@@ -74,7 +57,7 @@ fn parse_else_blocks(
             report,
             syntax::TokenKind::Identifier)?;
 
-        Ok(Some(parse_braced_block(report, walker)?))
+        Ok(Some(asm::parser::parse_braced_toplevel(report, walker)?))
     }
     else if directive_name == "elif"
     {

src/asm/parser/directive_ruledef.rs

@@ -1,6 +1,17 @@
 use crate::*;
 
 
+#[derive(Clone, Debug)]
+pub struct AstDirectiveMacro
+{
+    pub header_span: diagn::Span,
+    pub pattern: AstMatchPattern,
+    pub contents: asm::AstTopLevel,
+
+    pub item_ref: Option<util::ItemRef::<asm::Ruledef>>,
+}
+
+
 #[derive(Clone, Debug)]
 pub struct AstDirectiveRuledef
 {
@@ -14,11 +25,18 @@ pub struct AstDirectiveRuledef
 }
 
 
+#[derive(Clone, Debug)]
+pub struct AstMatchPattern
+{
+    pub span: diagn::Span,
+    pub parts: Vec<AstRulePatternPart>,
+}
+
+
 #[derive(Clone, Debug)]
 pub struct AstRule
 {
-    pub pattern_span: diagn::Span,
-    pub pattern: Vec<AstRulePatternPart>,
+    pub pattern: AstMatchPattern,
     pub expr: expr::Expr,
 }
 
@@ -97,13 +115,60 @@ pub fn parse(
 }
 
 
+pub fn parse_macro(
+    report: &mut diagn::Report,
+    walker: &mut syntax::Walker,
+    header_span: diagn::Span)
+    -> Result<AstDirectiveMacro, ()>
+{
+    let pattern = parse_match_pattern(
+        report,
+        walker,
+        false)?;
+
+    let contents = asm::parser::parse_braced_toplevel(
+        report,
+        walker)?;
+
+    walker.expect_linebreak(report)?;
+
+    Ok(AstDirectiveMacro {
+        header_span,
+        pattern,
+        contents,
+
+        item_ref: None,
+    })
+}
+
+
 fn parse_rule(
     report: &mut diagn::Report,
     walker: &mut syntax::Walker,
     is_subruledef: bool)
     -> Result<AstRule, ()>
 {
-    let mut pattern_span = diagn::Span::new_dummy();
+    let pattern = parse_match_pattern(
+        report,
+        walker,
+        is_subruledef)?;
+
+    let expr = expr::parse(report, walker)?;
+
+    Ok(AstRule {
+        pattern,
+        expr,
+    })
+}
+
+
+fn parse_match_pattern(
+    report: &mut diagn::Report,
+    walker: &mut syntax::Walker,
+    is_subruledef: bool)
+    -> Result<AstMatchPattern, ()>
+{
+    let mut span = diagn::Span::new_dummy();
     let mut pattern = Vec::new();
     let mut has_used_empty_specifier = false;
 
@@ -118,7 +183,7 @@ fn parse_rule(
         let tk = walker.next_token();
         walker.advance_to_token_end(&tk);
 
-        pattern_span = pattern_span.join(tk.span);
+        span = span.join(tk.span);
 
 
         if tk.kind == syntax::TokenKind::BraceOpen
@@ -136,7 +201,7 @@ fn parse_rule(
                 pattern.push(AstRulePatternPart::Parameter(param));
 
                 let tk_close = walker.expect(report, syntax::TokenKind::BraceClose)?;
-                pattern_span = pattern_span.join(tk_close.span);
+                span = span.join(tk_close.span);
             }
         }
 
@@ -163,7 +228,6 @@ fn parse_rule(
         }
     }
 
-
     let tk_heavy_arrow = walker.expect(report, syntax::TokenKind::HeavyArrowRight)?;
 
     if pattern.len() == 0 && !has_used_empty_specifier
@@ -175,13 +239,9 @@ fn parse_rule(
         return Err(());
     }
 
-
-    let expr = expr::parse(report, walker)?;
-
-    Ok(AstRule {
-        pattern_span,
-        pattern,
-        expr,
+    Ok(AstMatchPattern {
+        span,
+        parts: pattern,
     })
 }
 

src/asm/parser/mod.rs

@@ -53,6 +53,7 @@ pub use directive_res::AstDirectiveRes;
 mod directive_ruledef;
 pub use directive_ruledef::{
     AstDirectiveRuledef,
+    AstDirectiveMacro,
     AstRule,
     AstRulePatternPart,
     AstRuleParameter,
@@ -90,6 +91,7 @@ pub enum AstAny
     DirectiveIf(AstDirectiveIf),
     DirectiveInclude(AstDirectiveInclude),
     DirectiveLabelAlign(AstDirectiveLabelAlign),
+    DirectiveMacro(AstDirectiveMacro),
     DirectiveNoEmit(AstDirectiveNoEmit),
     DirectiveOnce(AstDirectiveOnce),
     DirectiveRes(AstDirectiveRes),
@@ -255,6 +257,23 @@ pub fn parse(
 }
 
 
+pub fn parse_braced_toplevel(
+    report: &mut diagn::Report,
+    walker: &mut syntax::Walker)
+    -> Result<AstTopLevel, ()>
+{
+    walker.expect(report, syntax::TokenKind::BraceOpen)?;
+
+    let block = parse_nested_toplevel(
+        report,
+        walker)?;
+
+    walker.expect(report, syntax::TokenKind::BraceClose)?;
+
+    Ok(block)
+}
+
+
 pub fn parse_nested_toplevel(
     report: &mut diagn::Report,
     walker: &mut syntax::Walker)
@@ -344,6 +363,7 @@ impl AstAny
             AstAny::DirectiveOnce(node) => node.header_span,
             AstAny::DirectiveRes(node) => node.header_span,
             AstAny::DirectiveRuledef(node) => node.header_span,
+            AstAny::DirectiveMacro(node) => node.header_span,
             AstAny::Instruction(node) => node.span,
             AstAny::Symbol(node) => node.decl_span,
         }

src/asm/resolver/iter.rs

@@ -220,7 +220,8 @@ impl<'ast, 'decls> ResolveIterator<'ast, 'decls>
             asm::AstAny::DirectiveLabelAlign(..) |
             asm::AstAny::DirectiveNoEmit(..) |
             asm::AstAny::DirectiveOnce(..) |
-            asm::AstAny::DirectiveRuledef(..) =>
+            asm::AstAny::DirectiveRuledef(..) |
+            asm::AstAny::DirectiveMacro(..) =>
             {
                 self.index += 1;
                 node = ResolverNode::None;

tests/macro/ok_arg_simple.asm

@@ -0,0 +1,5 @@
+#macro emit {x: u8} => {
+    #d8 {x}
+}
+
+emit 0xab ; = 0xab

tests/macro/ok_simple.asm

@@ -0,0 +1,5 @@
+#macro zero => {
+    #d8 0
+}
+
+zero ; = 0x00