21

所以我有以下我正在尝试调试的宏代码。我从Rust Book的“深渊”一节中摘取了它。我重命名了宏中的变量以更密切地关注这篇文章。

我的目标是让程序打印出 BCT 程序的每一行。我很清楚这是非常繁重的编译器。

rustc 给我的唯一错误是：

user@debian:~/rust/macros$ rustc --pretty expanded src/main.rs -Z unstable-options > src/main.precomp.rs
src/main.rs:151:34: 151:35 error: no rules expected the token `0`
src/main.rs:151     bct!(0, 1, 1, 1, 0, 0, 0; 1, 0);

我可以采取哪些步骤来确定问题来自宏的何处？

这是我的代码：

fn main() {
{
    // "Bitwise Cyclic Tag" automation through macros
    macro_rules! bct {
        // cmd 0:  0 ... => ...
        (0, $($program:tt),* ; $_head:tt)
            => (bct_p!($($program),*, 0 ; ));
        (0, $($program:tt),* ; $_head:tt, $($tail:tt),*)
            => (bct_p!($($program),*, 0 ; $($tail),*));

        // cmd 1x:  1 ... => 1 ... x
        (1, $x:tt, $($program:tt),* ; 1)
            => (bct_p!($($program),*, 1, $x ; 1, $x));
        (1, $x:tt, $($program:tt),* ; 1, $($tail:tt),*)
            => (bct_p!($($program),*, 1, $x ; 1, $($tail),*, $x));

        // cmd 1x:  0 ... => 0 ...
        (1, $x:tt, $($program:tt),* ; $($tail:tt),*)
            => (bct_p!($($program),*, 1, $x ; $($tail),*));

        // halt on empty data string
        ( $($program:tt),* ; )
            => (());
        }

    macro_rules! print_bct {
        ($x:tt ; )
            => (print!("{}", stringify!($x)));
        ( ; $d:tt)
            => (print!("{}", stringify!($d)));
        ($x:tt, $($program:tt),* ; )
            => {
                print!("{}", stringify!($x));
                print_bct!($program ;);
            };
        ($x:tt, $($program:tt),* ; $($data:tt),*)
            => {
                print!("{}", stringify!($x));
                print_bct!($program ; $data);
            };
        ( ; $d:tt, $($data:tt),*)
            => {
                print!("{}", stringify!($d));
                print_bct!( ; $data);
            };
    }

    macro_rules! bct_p {
        ($($program:tt),* ; )
            => {
                print_bct!($($program:tt),* ; );
                println!("");
                bct!($($program),* ; );
            };
        ($($program:tt),* ; $(data:tt),*)
            => {
                print_bct!($($program),* ; $($data),*);
                println!("");
                bct!($($program),* ; $($data),*);
            };
    }

    // the compiler is going to hate me...
    bct!(0, 1, 1, 1, 0, 0, 0; 1, 0);
}
4

3 回答 3

38

有两种主要方法可以调试无法扩展的宏：

  • trace_macros!和
  • log_syntax!

（注意。两者都是功能门控，在同名功能下，因此需要夜间编译器才能工作，multirust这使得在此类工作的版本之间切换很容易。）

trace_macros!(...)接受一个布尔参数来打开或关闭宏跟踪（即它是有状态的），如果它打开，编译器将在扩展时打印每个宏调用及其参数。通常一个人只想trace_macros!(true);在 crate 的顶部抛出一个调用，例如，如果将以下内容添加到代码的顶部：

#![feature(trace_macros)]

trace_macros!(true);

然后输出如下所示：

bct! { 0 , 1 , 1 , 1 , 0 , 0 , 0 ; 1 , 0 }
bct_p! { 1 , 1 , 1 , 0 , 0 , 0 , 0 ; 0 }
<anon>:68:34: 68:35 error: no rules expected the token `0`
<anon>:68     bct!(0, 1, 1, 1, 0, 0, 0; 1, 0);
                                           ^
playpen: application terminated with error code 101

这有望缩小问题范围：bct_p!调用在某种程度上是无效的。仔细看就会发现问题，第二条手臂的左侧应该bct_p使用data:tt什么时候使用$data:tt，即缺少$。

    ($($program:tt),* ; $(data:tt),*)

修复允许编译取得进展。

log_syntax!在这种情况下并没有那么立即有用，但仍然是一个简洁的工具：它接受任意参数并在扩展时将它们打印出来，例如

#![feature(log_syntax)]

log_syntax!("hello", 1 2 3);

fn main() {}

"hello" , 1 2 3将在编译时打印。这对于检查其他宏调用中的内容最有用。

（一旦展开工作，调试生成代码中任何问题的最佳工具是使用 .NB 的--pretty expanded参数rustc。这需要-Z unstable-options传递标志来激活它。）

于 2015-05-13T07:24:11.617 回答
18

另一个用于轻松查看扩展的好工具是cargo-expand。

它可以安装：

cargo install cargo-expand

然后很简单地用作：

cargo expand

或者更精确地定位特定的测试文件（例如tests/simple.rs）：

cargo expand --test simple

请务必查看--help，有很多选项可以缩小扩展范围。您甚至可以针对单个项目（结构、fns 等）进行扩展！

于 2019-02-16T01:43:28.450 回答
0

调试很有趣。我从最简单的输入开始，然后从那里开始工作。我发现我在打印功能的过程中遇到了问题（重写，所以它只打印输入而不循环回来！）。

我还添加了更明确的规则，然后在一切正常后将其删除（当然，一路测试）。一旦我知道每个单独的部分都在编译，并且打印功能正在工作，我就能够验证宏的输出。下面的宏有时会在不应该运行的时候运行，但它可以编译、打印并且是可调试的。我对目前的状态很满意，可以在这里发布。

fn main() {
    // "Bitwise Cyclic Tag" automation through macros
    macro_rules! bct {
        // cmd 0:  0 ... => ...
        (0, $($program:tt),* ; $_head:tt)
            => (pbct!($($program),*, 0 ; ));
        (0, $($program:tt),* ; $_head:tt, $($tail:tt),*)
            => (pbct!($($program),*, 0 ; $($tail),*));

        // cmd 1x:  1 ... => 1 ... x
        (1, $x:tt, $($program:tt),* ; 1)
            => (pbct!($($program),*, 1, $x ; 1, $x));
        (1, $x:tt, $($program:tt),* ; 1, $($tail:tt),*)
            => (pbct!($($program),*, 1, $x ; 1, $($tail),*, $x));

        // cmd 1x:  0 ... => 0 ...
        (1, $x:tt, $($program:tt),* ; $($tail:tt),*)
            => (pbct!($($program),*, 1, $x ; $($tail),*));

        // halt on empty data string
        ( $($program:tt),* ; )
            => (());
    }

    macro_rules! println_bct {
        () =>
            (println!(""));
        (;) =>
            (println!(":"));

        ($d:tt) =>
            (println!("{}", stringify!($d)));
        ($d:tt, $($data:tt),*) => {
            print!("{}", stringify!($d));
            println_bct!($($data),*);
        };
        ( ; $($data:tt),*) => {
            print!(":");
            println_bct!($($data),*);
        };

        ($x:tt ; $($data:tt),*) => {
            print!("{}", stringify!($x));
            println_bct!( ; $($data),*);
        };
        ($x:tt, $($program:tt),* ; $($data:tt),*) => {
            print!("{}", stringify!($x));
            println_bct!($($program),* ; $($data),*);
        };
    }

    macro_rules! pbct {
        ($($program:tt),* ; $($data:tt),*) => {
            println_bct!($($program),* ; $($data),*);
            bct!($($program),* ; $($data),*);
        };
    }

    pbct!(0, 0, 1, 1, 1, 0, 0, 0 ; 1, 0, 1);

    // This one causes the compiler to hit recursion limits, heh
    // pbct!(0, 0, 1, 1, 1, 1, 1, 0 ; 1, 0, 1);
}
于 2015-05-12T22:00:31.813 回答