Building Domain Specific Syntax

In this lesson, you will learn how to leverage Rust's macro_rules! to transform a human-readable, domain-specific configuration language into standard Rust struct initializers at compile time.

Why Build a Custom DSL?

When working with low-level systems, you often deal with complex hardware configurations—like sensor sampling rates, interrupt priority maps, or memory region attributes. Standard struct initialization can become noisy and error-prone when repeated across a firmware project. A custom DSL allows you to define a declarative syntax that captures the intent of your hardware configuration, ensuring that the final output is always a valid, type-checked Rust struct.

The Macro Pattern

To build this, we define a macro that acts as a parser for our custom syntax. Instead of writing verbose Config { field: val, ... } calls, we can create a syntax that reads like a configuration file.

Consider a macro that configures a hypothetical DMA controller:

macro_rules! configure_dma {
    ($name:ident => {
        src: $src:expr,
        dst: $dst:expr,
        priority: $prio:expr
    }) => {
        let $name = DmaConfig {
            source_addr: $src as *const u32,
            dest_addr: $dst as *mut u32,
            priority_level: $prio,
        };
    };
}

// Usage:
configure_dma!(sensor_transfer => {
    src: 0x4000_1000,
    dst: 0x2000_0000,
    priority: 2
});

How It Works

1. Token Matching: The macro uses pattern matching to consume your custom syntax (e.g., the => separator and curly-braced blocks).
2. Fragment Transformation: Inside the macro, the captured identifiers and expressions ($src, $prio) are injected into the standard Rust DmaConfig constructor.
3. Compile-time Validation: Because the macro expands into actual Rust code before compilation, any syntax errors or type mismatches in the user's DSL are caught by the standard compiler, providing familiar error messages.

By decoupling the intent (the DSL syntax) from the implementation (the struct structure), you create a configuration layer that is safer, cleaner, and easier to audit for complex system states.

Key Takeaway: Custom DSLs created via macros act as a compile-time translation layer that hides boilerplate, enforces consistent structure, and makes declarative configuration safer for critical system parameters.