字节码编译器：macro_rules!、回填和常量池

1
use syn::{Data, DeriveInput, Fields, ItemEnum, parse_macro_input};

1
#[proc_macro]
2
pub fn opcode_set(input: TokenStream) -> TokenStream {
3
    let item = parse_macro_input!(input as ItemEnum);
4
    match expand_opcodes(&item) {
5
        Ok(tokens) => tokens.into(),
6
        Err(error) => error.to_compile_error().into(),
7
    }
8
}

1
error: expected `enum`
2
 --> src/bin/ch10_opcode_set_struct.rs:4:9
3
  |
4
4 |     pub struct Tiny {
5
  |         ^^^^^^
6
...

1
fn expand_opcodes(item: &ItemEnum) -> syn::Result<TokenStream2> {
2
    let attrs = &item.attrs;
3
    let vis = &item.vis;
4
    let name = &item.ident;
5
    let variants = &item.variants;

1
    let arms = variants.iter().map(|variant| {
2
        let variant_name = &variant.ident;
3
        if variant.fields.is_empty() {
4
            quote!(#name::#variant_name => stringify!(#variant_name))
5
        } else {
6
            quote!(#name::#variant_name(..) => stringify!(#variant_name))
7
        }
8
    });

1
//! compile time, in the compiler's process, and speak in tokens. So far two
2
//! flavours live here:
3
//!
4
//! * [`macro@Spanned`] - a **derive** macro that writes the boring
5
//!   `impl pebble_span::Spanned` for AST nodes.
6
//! * [`opcode_set`] - a **function-like** macro that turns a declarative list of
7
//!   opcodes into an enum plus a `name()` table.
8
//!
9
//! (A third, **declarative** kind, `macro_rules!`, lives next to the code
10
//! that uses it in `pebble-bytecode`.)

1
$ cargo run --quiet --bin ch10_opcode_set
2
Const(7) is called Const
3
Nil is called Nil
4
Jump(3) is called Jump

1
$ cargo run --quiet --bin ch10_sizes
2
enum Op        = 8 bytes
3
Option<Op>     = 8 bytes
4
repr(C) struct = 8 bytes

1
/// A compile-time constant.
2
#[derive(Debug)]
3
pub enum Constant {
4
    Int(i64),
5
}

1
    /// The instructions.
2
    #[must_use]
3
    pub fn code(&self) -> &[Opcode] {
4
        &self.code
5
    }
6

7
    /// The constant pool.
8
    #[must_use]
9
    pub fn constants(&self) -> &[Constant] {
10
        &self.constants
11
    }
12
}

1
/// Compiles a parsed program into one chunk.
2
#[must_use]
3
pub fn compile(program: &Program) -> Chunk {
4
    let mut compiler = Compiler::default();
5
    compiler.compile_body(&program.stmts, false);
6
    compiler.chunk
7
}
8

9
#[derive(Default)]
10
struct Compiler {
11
    chunk: Chunk,
12
}

1
impl Compiler {
2
    fn emit(&mut self, op: Opcode, span: Span) -> usize {
3
        self.chunk.emit(op, span)
4
    }
5

6
    fn compile_body(&mut self, stmts: &[Stmt], in_function: bool) {
7
        let span = stmts.first().map_or(Span::DUMMY, Spanned::span);
8
        let Some((last, init)) = stmts.split_last() else {
9
            self.emit(Opcode::Nil, span);
10
            if in_function {
11
                self.emit(Opcode::Return, span);
12
            }
13
            return;
14
        };

1
        for stmt in init {
2
            self.compile_stmt(stmt);
3
        }
4
        if let Stmt::Expr { expr, .. } = last {
5
            self.compile_expr(expr);
6
        } else {
7
            self.compile_stmt(last);
8
            self.emit(Opcode::Nil, span);
9
        }
10
        if in_function {
11
            self.emit(Opcode::Return, span);
12
        }
13
    }

1
    fn compile_stmt(&mut self, stmt: &Stmt) {
2
        let span = stmt.span();
3
        match stmt {
4
            Stmt::Expr { expr, .. } => {
5
                self.compile_expr(expr);
6
                self.emit(Opcode::Pop, span);
7
            }
8
            _ => todo!("statement"),
9
        }
10
    }

1
$ cargo test -p pebble-bytecode
2
running 1 test
3
test tests::compiles_arithmetic ... ok
4

5
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

1
    fn compile_src(src: &str) -> Compiled {
2
        let result = parse(SourceId(0), src);
3
        assert!(result.is_ok(), "parse errors: {:?}", result.diagnostics);
4
        let compiled = compile(&result.program);
5
        assert!(
6
            compiled.is_ok(),
7
            "compile errors: {:?}",
8
            compiled.diagnostics
9
        );
10
        compiled.compiled
11
    }

1
pebble-bytecode.workspace = true

1
    /// Print the compiled bytecode disassembly before running.
2
    #[arg(long)]
3
    pub(crate) dump_bytecode: bool,

1
    if args.dump_bytecode {
2
        let compiled = compile(&parsed.program);
3
        if sources::emit(&compiled.diagnostics, &source.map) {
4
            return Ok(1);
5
        }
6
        print!("{}", compiled.compiled.chunk().disassemble());
7
    }

1
$ pebble run --dump-bytecode 1.pebble
2
== constants ==
3
     0 Int(1)
4
     1 Int(2)
5
     2 Int(3)
6
== code ==
7
     0 Const 0
8
     1 Const 1
9
     2 Const 2
10
     3 Mul
11
     4 Add
12
7

1
$ pebble run --dump-bytecode examples/fib.pebble
2

3
thread 'main' (123062) panicked at crates/pebble-bytecode/src/lib.rs:225:18:
4
not yet implemented: statement
5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

1
$ cargo run --quiet --bin ch10_float_bits
2
0.0 == -0.0        -> true
3
NaN == NaN         -> false
4
bits equal 0/-0    -> false
5
bits equal NaN/NaN -> true

1
impl Constant {
2
    fn same(&self, other: &Constant) -> bool {
3
        match (self, other) {
4
            (Constant::Nil, Constant::Nil) => true,
5
            (Constant::Bool(a), Constant::Bool(b)) => a == b,
6
            (Constant::Int(a), Constant::Int(b)) => a == b,
7
            (Constant::Float(a), Constant::Float(b)) => a.to_bits() == b.to_bits(),
8
            (Constant::Str(a), Constant::Str(b)) => a == b,
9
            // Function prototypes are never deduplicated.
10
            _ => false,
11
        }
12
    }
13
}

1
    /// Adds a scalar constant, reusing an identical one already in the pool.
2
    ///
3
    /// Function prototypes are never deduplicated.
4
    pub(crate) fn intern(&mut self, constant: Constant) -> u32 {
5
        if !matches!(constant, Constant::Function(_))
6
            && let Some(position) = self
7
                .constants
8
                .iter()
9
                .position(|existing| existing.same(&constant))
10
        {
11
            return position as u32;
12
        }
13
        self.add_constant(constant)
14
    }

1
        /// Push `true`.
2
        True,
3
        /// Push `false`.
4
        False,

1
            Expr::Nil { .. } => {
2
                self.emit(Opcode::Nil, span);
3
            }
4
            Expr::Bool { value, .. } => {
5
                self.emit(if *value { Opcode::True } else { Opcode::False }, span);
6
            }
7
            Expr::Int { value, .. } => {
8
                let index = self.chunk.intern(Constant::Int(*value));
9
                self.emit(Opcode::Const(index), span);
10
            }

1
            Stmt::Let { name, value, .. } => {
2
                self.compile_expr(value);
3
                let index = self.name_const(&name.name);
4
                self.emit(Opcode::DefineName(index), span);
5
            }

1
            Expr::Var { name, .. } => {
2
                let index = self.name_const(&name.name);
3
                self.emit(Opcode::GetName(index), span);
4
            }

1
            Expr::Assign { target, value, .. } => match target.as_ref() {
2
                Expr::Var { name, .. } => {
3
                    self.compile_expr(value);
4
                    let index = self.name_const(&name.name);
5
                    self.emit(Opcode::SetName(index), span);
6
                }
7
                _ => todo!("assignment target"),
8
            },