小贝子编程

如何编写递归 for 循环"repeat"宏以使用 CPP 预处理器生成 C 代码？



我想强制预处理器为我做一些自动代码生成。我不需要太多:只需要一个包含另一个for循环的简单for循环。[1]

我已经读了所有我能读到的关于宏观膨胀的东西，当蓝色油漆出现时，我不再傻笑了。在好的时候，我甚至可以解释为什么需要多层宏来通过标记粘贴生成函数名。我已经让for循环工作了。但是，当涉及到在循环中放入循环时，我只能随机地使用DEFER、EVAL和阻挠，并期待最好的结果。

我不会被理性的召唤所吓倒。我真的想用标准的C预处理器来做这个。我保证，无论结果如何，我、我的雇主和我的继承人都不会以技术渎职为由起诉你们。我保证不允许任何人在没有适当的安全眼镜的情况下维护代码，甚至查看代码。如果你愿意，就假装我只是出于理论兴趣问你。或者我唯一的其他选择是使用M4:因为如果CPP中的递归宏是扭曲的，那么M4当然是整只鸡。

我找到的最好的参考资料是一个9年前的Usenet帖子:http://comp.std.c.narkive.com/5WbJfCof/double-cpp-expansion

它开始跑题，有点琐碎和好斗的语气，并且是我无法理解的。但我想我寻找的答案就在某处。

下一个最好的是CPP滥用头文件斗篷的文档:https://github.com/pfultz2/Cloak/wiki/C-Preprocessor-tricks,技巧,和习语

它采用了一种不同的迭代方法，也许可以满足我的需要。但这也是一个很好的概述。

这里有一些简化的代码来显示我被卡住的地方。

repeat.h: 

#define REPEAT(macro, times, start_n, next_func, next_arg, macro_args...) 
    _REPEAT_ ## times(macro, start_n, next_func, next_arg, ## macro_args)
#define REPEAT_ADD_ONE(macro, times, start_n, macro_args... )                    
    REPEAT(macro, times, start_n, _REPEAT_ADD_ONE, 0, ## macro_args)
#define _REPEAT_ADD_ONE(n, ignore...) _REPEAT_ADD_ONE_ ## n
#define _REPEAT_0(args...)  /* empty */
#define _REPEAT_1(macro, n, func, i, args...) macro(n, ## args) 
#define _REPEAT_2(m, n, f, i, a...) m(n, ## a); _REPEAT_1(m, f(n, i), f, i, ## a)
#define _REPEAT_3(m, n, f, i, a...) m(n, ## a); _REPEAT_2(m, f(n, i), f, i, ## a)
#define _REPEAT_4(m, n, f, i, a...) m(n, ## a); _REPEAT_3(m, f(n, i), f, i, ## a)
#define _REPEAT_5(m, n, f, i, a...) m(n, ## a); _REPEAT_4(m, f(n, i), f, i, ## a)
#define _REPEAT_6(m, n, f, i, a...) m(n, ## a); _REPEAT_5(m, f(n, i), f, i, ## a)
#define _REPEAT_7(m, n, f, i, a...) m(n, ## a); _REPEAT_6(m, f(n, i), f, i, ## a)
#define _REPEAT_8(m, n, f, i, a...) m(n, ## a); _REPEAT_7(m, f(n, i), f, i, ## a)
#define _REPEAT_9(m, n, f, i, a...) m(n, ## a); _REPEAT_8(m, f(n, i), f, i, ## a)
#define _REPEAT_10(m, n, f, i, a...) m(n, ## a); _REPEAT_9(m, f(n, i), f, i, ## a)
#define _REPEAT_ADD_ONE_0 1
#define _REPEAT_ADD_ONE_1 2
#define _REPEAT_ADD_ONE_2 3
#define _REPEAT_ADD_ONE_3 4
#define _REPEAT_ADD_ONE_4 5
#define _REPEAT_ADD_ONE_5 6
#define _REPEAT_ADD_ONE_6 7
#define _REPEAT_ADD_ONE_7 8
#define _REPEAT_ADD_ONE_8 9
#define _REPEAT_ADD_ONE_9 10
#define _REPEAT_ADD_ONE_10 11
#define _REPEAT_ADD_0(x) x
#define _REPEAT_ADD_1(x) _REPEAT_ADD_ONE(x)
#define _REPEAT_ADD_2(x) _REPEAT_ADD_1(_REPEAT_ADD_ONE(x))
#define _REPEAT_ADD_3(x) _REPEAT_ADD_2(_REPEAT_ADD_ONE(x))
#define _REPEAT_ADD_4(x) _REPEAT_ADD_3(_REPEAT_ADD_ONE(x))
#define _REPEAT_ADD_5(x) _REPEAT_ADD_4(_REPEAT_ADD_ONE(x))
#define _REPEAT_ADD_6(x) _REPEAT_ADD_5(_REPEAT_ADD_ONE(x))
#define _REPEAT_ADD_7(x) _REPEAT_ADD_6(_REPEAT_ADD_ONE(x))
#define _REPEAT_ADD_8(x) _REPEAT_ADD_7(_REPEAT_ADD_ONE(x))
#define _REPEAT_ADD_9(x) _REPEAT_ADD_8(_REPEAT_ADD_ONE(x))
#define _REPEAT_ADD_10(x) _REPEAT_ADD_9(_REPEAT_ADD_ONE(x))

sample.c: 

#include "repeat.h"
#define INNER_MACRO(inner, outer) if (inner == outer) printf("Matchn")
#define INNER_BLOCK  { if (inner == outer) printf("Matchn"); }
#define OUTER_MACRO_INNER_MACRO(outer) REPEAT_ADD_ONE(INNER_MACRO, 3, 0, outer)
#define OUTER_BLOCK_INNER_MACRO { REPEAT_ADD_ONE(INNER_MACRO, 3, 0, outer); }
#define OUTER_MACRO_INNER_BLOCK(outer) REPEAT_ADD_ONE(INNER_BLOCK, 3, 0, outer)
#define OUTER_BLOCK_INNER_BLOCK { REPEAT_ADD_ONE(INNER_BLOCK, 3, 0, outer); }
void outer_macro_inner_macro() {
    REPEAT_ADD_ONE(OUTER_MACRO_INNER_MACRO, 2, 1);
}
void outer_macro_inner_block() {
    REPEAT_ADD_ONE(OUTER_MACRO_INNER_BLOCK, 2, 1);
}
void outer_block_inner_macro() {
    REPEAT_ADD_ONE(OUTER_BLOCK_INNER_MACRO, 2, 1);
}
void outer_block_inner_block() {
    REPEAT_ADD_ONE(OUTER_BLOCK_INNER_BLOCK, 2, 1);
}

在sample.c中，我已经展示了四种接近我想要的变化。但没有一个是完全正确的。下面是我使用"cpp sample.c> out.c;astyle out.c;" 

void outer_macro_inner_macro() {
    REPEAT_ADD_ONE(INNER_MACRO, 3, 0, 1);
    REPEAT_ADD_ONE(INNER_MACRO, 3, 0, 2);
}
void outer_macro_inner_block() {
    REPEAT_ADD_ONE({ if (inner == outer) printf("Matchn"); }, 3, 0, 1);
    REPEAT_ADD_ONE({ if (inner == outer) printf("Matchn"); }, 3, 0, 2);
}
void outer_block_inner_macro() {
    {
        if (0 == outer) printf("Matchn");
        if (1 == outer) printf("Matchn");
        if (2 == outer) printf("Matchn");
    }(1);
    {
        if (0 == outer) printf("Matchn");
        if (1 == outer) printf("Matchn");
        if (2 == outer) printf("Matchn");
    }(2);
}
void outer_block_inner_block() {
    { {
            if (inner == outer) printf("Matchn");
        }(0, outer);
        {
            if (inner == outer) printf("Matchn");
        }(1, outer);
        {
            if (inner == outer) printf("Matchn");
        }(2, outer);
    }(1);
    { {
            if (inner == outer) printf("Matchn");
        }(0, outer);
        {
            if (inner == outer) printf("Matchn");
        }(1, outer);
        {
            if (inner == outer) printf("Matchn");
        }(2, outer);
    }(2);
}

下面是我想要得到的输出:

void desired_results() {
   {
       if (0 == 1) printf("Matchn");
       if (1 == 1) printf("Matchn");
       if (2 == 1) printf("Matchn");
   };
   {
       if (0 == 2) printf("Matchn");
       if (1 == 2) printf("Matchn");
       if (2 == 2) printf("Matchn");
   };
}

本质上，如果我使用一个块作为外部循环体，我可以让事情工作，但如果我使用一个类似函数的宏就不行。但是我需要使用带有参数的宏，以便循环体可以将循环计数器用作常量而不是变量。

"宏"-"宏"方式的问题是对REPEAT_ADD_ONE()的内部递归调用没有展开。答案似乎是将内部循环的扩展推迟到创建外部循环之后，然后强制执行另一次扩展内部循环的传递。但由于某种原因，我的"随机猴子"方法尚未产生解决方案…

[1]意思是轻描淡写。

Vesa Karvonen的"Order"库/语言绝对可以为您做到这一点。它在C预处理器中实现了不受限制的递归和循环，并且作为一个非常酷的奖励，它用"合适的"编程语言的简洁语法来修饰它(澄清一下:这不是一个可选的预处理器，它只是做了大量的标记粘贴，以保持其关键字简短。它仍然是纯CPP)。

它使用一种相当不同的技术，将元程序转换为CPS，然后将它们传递给具有潜在数万亿步骤的单个循环结构，并以严格的线性方式执行元程序。因此，循环和递归函数可以随心所欲地嵌套，因为它们不需要单独的驱动程序，需要相互交互并将彼此涂成蓝色。

是的，真的，有人使用CPP宏实现了一个完整的虚拟机和解释器。恐吓。

(编辑:如果Rosetta Code也停止为您工作，请尝试存档版本)

在这里的答案的帮助下(以及研究P99, Chaos, Order和Cloak)，我认为我有一个相当简单和紧凑的概念验证(1)。因为我只想要"重复"功能，而不是一个完整的解释器，所以我采用了一种与其他解决方案不同的方法。我没有创建通用的"if"、"while"或"when"宏，而是直接使用了一系列"递减"宏，这些宏扩展为所需的宏，并在n-1时调用宏。

#ifndef _REPEAT_H
#define _REPEAT_H
// Usage: REPEAT_ADD_ONE(macro, times, start_n, macro_args... )
//        Recursion allowed if inner macros use REPEAT_ADD_ONE_INNER().
//        This demo header only allows 3 layers of recursion and max n=10.
//        Sample code at bottom.
#define REPEAT_ADD_ONE(macro, times, start_n, macro_args... )           
    _REPEAT_EXPAND_3(REPEAT_ADD_ONE_INNER(macro, times, start_n, ## macro_args))
#define REPEAT_ADD_ONE_INNER(macro, times, start_n, macro_args... )     
    _REPEAT_ ## times(macro, start_n, _REPEAT_ADD_ONE, ## macro_args)
#define _REPEAT_0(args...)  /* empty */
#define _REPEAT_1(macro, n, func, args...) _REPEAT_DEFER(macro)(n, ## args)
#define _REPEAT_2(m, n, f, a...) _REPEAT_DEFER(m)(n, ## a); _REPEAT_1(m, f(n), f, ## a)
#define _REPEAT_3(m, n, f, a...) _REPEAT_DEFER(m)(n, ## a); _REPEAT_2(m, f(n), f, ## a)
#define _REPEAT_4(m, n, f, a...) _REPEAT_DEFER(m)(n, ## a); _REPEAT_3(m, f(n), f, ## a)
#define _REPEAT_5(m, n, f, a...) _REPEAT_DEFER(m)(n, ## a); _REPEAT_4(m, f(n), f, ## a)
#define _REPEAT_6(m, n, f, a...) _REPEAT_DEFER(m)(n, ## a); _REPEAT_5(m, f(n), f, ## a)
#define _REPEAT_7(m, n, f, a...) _REPEAT_DEFER(m)(n, ## a); _REPEAT_6(m, f(n), f, ## a)
#define _REPEAT_8(m, n, f, a...) _REPEAT_DEFER(m)(n, ## a); _REPEAT_7(m, f(n), f, ## a)
#define _REPEAT_9(m, n, f, a...) _REPEAT_DEFER(m)(n, ## a); _REPEAT_8(m, f(n), f, ## a)
#define _REPEAT_10(m, n, f, a...) _REPEAT_DEFER(m)(n, ## a); _REPEAT_9(m, f(n), f, ## a)
// ...
#define _REPEAT_ADD_ONE(n, ignore...) _REPEAT_ADD_ONE_ ## n
#define _REPEAT_ADD_ONE_0 1
#define _REPEAT_ADD_ONE_1 2
#define _REPEAT_ADD_ONE_2 3
#define _REPEAT_ADD_ONE_3 4
#define _REPEAT_ADD_ONE_4 5
#define _REPEAT_ADD_ONE_5 6
#define _REPEAT_ADD_ONE_6 7
#define _REPEAT_ADD_ONE_7 8
#define _REPEAT_ADD_ONE_8 9
#define _REPEAT_ADD_ONE_9 10
#define _REPEAT_ADD_ONE_10 11
// ...
#define _REPEAT_EMPTY()
#define _REPEAT_DEFER(token) token _REPEAT_EMPTY()
#define _REPEAT_EXPAND_3(args...) _REPEAT_EXPAND(_REPEAT_EXPAND(_REPEAT_EXPAND(args)))
#define _REPEAT_EXPAND(args...) args
// ...
#endif // _REPEAT_H
#ifdef SAMPLE_CODE
// to generate code:   cpp -DSAMPLE_CODE sample.c 
// or easier to read:  cpp -DSAMPLE_CODE sample.c > out.c; astyle out.c; less out.c
// to compile and run: gcc  -Wall -O3 -DSAMPLE_CODE sample.c -o sample
int printf(const char *format, ...);
#define BODY(i) printf("%dn", i);
void simple(void) {
    REPEAT_ADD_ONE(BODY, 5, 1);
}
#define INNER(k, j, i) 
    printf("(%d, %d, %d)n", i, j, k);          
    if (i == j && j == k) printf("Match!n")
#define MIDDLE(j, i) REPEAT_ADD_ONE_INNER(INNER, 2, 2, j, i)
#define OUTER(i) REPEAT_ADD_ONE_INNER(MIDDLE, 3, 0, i)
void recursive(void) {
    REPEAT_ADD_ONE(OUTER, 2, 1);
}
int main() {
    simple();
    recursive();
    return 0;
}
#endif // SAMPLE_CODE

我仍然在努力理解许多微妙之处，但正如其他人指出的那样，一般规则是没有宏可以扩展自己。解决这个问题的方法是创建一个宏，将其扩展到可以调用自己的地方，然后在结果周围放置一个包装器以完成扩展。

我最后使用的(常见的)技巧是利用这样一个事实，即函数类型的宏只在紧接括号时展开。可以使用"defer"宏，在被调用的宏名称及其括号之间放置一个"空"标记，然后将其"展开"作为另一个宏的参数。

由于实参的展开发生在与初始展开不同的上下文中，因此初始宏将再次展开。在我的解决方案中，每一级潜在递归都需要一级展开。如果想要理解代码，可以减少检查中间结果的展开次数。

谢谢你的帮助!

(1)正确，当应用于递归预处理器宏时，"相当简单"的标准是相当宽松的。不过，它相当紧凑。

P99可能提供您正在寻找的东西。它有几种类型的宏迭代器，简单的像P99_UNROLL, P99_SER等和一个通用的P99_FOR .

我不确定我遵循你所有的宏在那里。这里的答案解释了如何创建一个通用的REPEAT宏，如下所示:

#define REPEAT(count, macro, ...) 
    WHEN(count) 
    ( 
        OBSTRUCT(REPEAT_INDIRECT) () 
        ( 
            DEC(count), macro, __VA_ARGS__ 
        ) 
        OBSTRUCT(macro) 
        ( 
            DEC(count), __VA_ARGS__ 
        ) 
    )
#define REPEAT_INDIRECT() REPEAT

接受一个计数、一个宏和用户数据。由于传入的宏是延迟的，因此可以直接递归地再次调用REPEAT宏。这是OUTER和INNER的重复宏:

#define OUTER(i, j) { REPEAT(j, INNER, i) }
#define INNER(j, i) if (j == INC(i)) printf("Matchn");
EVAL(REPEAT(2, OUTER, 3))

输出如下:

{ 
    if (0 == 1) printf("Matchn"); 
    if (1 == 1) printf("Matchn"); 
    if (2 == 1) printf("Matchn"); 
}
{
    if (0 == 2) printf("Matchn"); 
    if (1 == 2) printf("Matchn"); 
    if (2 == 2) printf("Matchn");
}

相关内容

最新更新


热门标签：

javascript python java c# php android html jquery c++ css ios sql mysql arrays asp.net json python-3.x ruby-on-rails .net sql-server django objective-c excel regex ruby linux ajax iphone xml vba spring asp.net-mvc database wordpress string postgresql wpf windows xcode bash git oracle list vb.net multithreading eclipse algorithm macos powershell visual-studio image forms numpy scala function api selenium