Wie verwende ich ein Makro für alle Moduldateien?

Ich habe zwei Module in separaten Dateien in derselben Kiste, in der die Kiste macro_rulesaktiviert wurde. Ich möchte die in einem Modul definierten Makros in einem anderen Modul verwenden.

// macros.rs
#[macro_export] // or not? is ineffectual for this, afaik
macro_rules! my_macro(...)

// something.rs
use macros;
// use macros::my_macro; <-- unresolved import (for obvious reasons)
my_macro!() // <-- how?

Ich habe momentan den Compilerfehler " macro undefined: 'my_macro'" ... getroffen, was Sinn macht; Das Makrosystem läuft vor dem Modulsystem. Wie kann ich das umgehen?

Makros in derselben Kiste

#[macro_use]
mod foo {
    macro_rules! bar {
        () => ()
    }
}

bar!();    // works

Wenn Sie das Makro in derselben Kiste verwenden möchten, benötigt das Modul, in dem Ihr Makro definiert ist, das Attribut #[macro_use].

Makros können nur verwendet werden, nachdem sie definiert wurden. Dies bedeutet, dass dies nicht funktioniert:

bar!();  // ERROR: cannot find macro `bar!` in this scope

#[macro_use]
mod foo {
    macro_rules! bar {
        () => ()
    }
}

Makros über Kisten

Um Ihr macro_rules!Makro aus anderen Kisten zu verwenden, benötigt das Makro selbst das Attribut #[macro_export]. Die importierende Kiste kann dann das Makro über importieren use crate_name::macro_name;.

Kiste util

#[macro_export]
macro_rules! foo {
    () => ()
}

Kiste user

use util::foo;

foo!();

Beachten Sie, dass Makros immer auf der obersten Ebene einer Kiste leben. Selbst wenn fooes sich in einem befinden würde mod bar {}, usermüsste die Kiste immer noch schreiben use util::foo;und nicht use util::bar::foo; .

Vor Rust 2018 mussten Sie Makros aus anderen Kisten importieren, indem Sie das Attribut #[macro_use]zur extern crate util;Anweisung hinzufügen . Das würde alle Makros von importieren util. Alternativ können #[macro_use(cat, dog)]nur die Makros catund importiert werden dog. Diese Syntax sollte nicht mehr erforderlich sein.

Weitere Informationen finden Sie im Kapitel Die Programmiersprache Rust zu Makros .

Diese Antwort ist ab Rust 1.1.0-stabil veraltet.

Sie müssen hinzufügen #![macro_escape]an der Spitze macros.rsund schließen sie mit , mod macros;wie erwähnt in dem Macros Handbuch .

$ cat macros.rs
#![macro_escape]

#[macro_export]
macro_rules! my_macro {
    () => { println!("hi"); }
}

$ cat something.rs
#![feature(macro_rules)]
mod macros;

fn main() {
    my_macro!();
}

$ rustc something.rs
$ ./something
hi

Zum späteren Nachschlagen,

$ rustc -v
rustc 0.13.0-dev (2790505c1 2014-11-03 14:17:26 +0000)

Wenn Sie #![macro_use]am Anfang Ihrer Datei Makros hinzufügen, werden alle Makros in main.rs gezogen.

Angenommen, diese Datei heißt node.rs:

#![macro_use]

macro_rules! test {
    () => { println!("Nuts"); }
}

macro_rules! best {
    () => { println!("Run"); }
}

pub fn fun_times() {
    println!("Is it really?");
}

Ihre main.rs würden irgendwann wie folgt aussehen:

mod node;  //We're using node.rs
mod toad;  //Also using toad.rs

fn main() {
    test!();
    best!();
    toad::a_thing();
}

Nehmen wir zum Schluss an, Sie haben eine Datei namens toad.rs, für die auch diese Makros erforderlich sind:

use node; //Notice this is 'use' not 'mod'

pub fn a_thing() {
  test!();

  node::fun_times();
}

Beachten Sie, dass modder Rest Ihrer Dateien über das useSchlüsselwort Zugriff darauf hat , sobald Dateien in main.rs mit gezogen wurden .

Ich bin in Rust 1.44.1 auf dasselbe Problem gestoßen, und diese Lösung funktioniert für spätere Versionen (bekannt für Rust 1.7).

Angenommen, Sie haben ein neues Projekt als:

src/
    main.rs
    memory.rs
    chunk.rs

In main.rs müssen Sie mit Anmerkungen versehen, dass Sie Makros aus der Quelle importieren. Andernfalls ist dies für Sie nicht ausreichend .

#[macro_use]
mod memory;
mod chunk;

fn main() {
    println!("Hello, world!");
}

In memory.rs können Sie also die Makros definieren und benötigen keine Anmerkungen:

macro_rules! grow_capacity {
    ( $x:expr ) => {
        {
            if $x < 8 { 8 } else { $x * 2 }
        }
    };
}

Schließlich können Sie es in chunk.rs verwenden , und Sie müssen das Makro hier nicht einfügen , da es in main.rs ausgeführt wird:

grow_capacity!(8);

Die positiv bewertete Antwort hat mich verwirrt, mit diesem Dokument als Beispiel wäre es auch hilfreich.