DEV Community: Horu

Strings as template parameters (C++20)

Horu — Sun, 07 May 2023 19:29:49 +0000

First if we want to create a new type for a template parameter we need to create a structural type, this means we cannot use private members or functions.

Our compile time string will contain our string and it will not use new or delete, it can be possible to use new and delete in a constexpr function block but in this case we cannot hold dynamic memory in a lifetime constexpr variable.

I wrote the following template which it holds a fixed string, and can be used with templates as well.



#include <algorithm>

template<std::size_t N>
struct CompTimeStr {
    char data[N] {};

    consteval CompTimeStr(const char (&str)[N]) {
        std::copy_n(str, N, data);
    }

    consteval bool operator==(const CompTimeStr<N> str) const {
        return std::equal(str.data, str.data+N, data);
    }

    template<std::size_t N2>
    consteval bool operator==(const CompTimeStr<N2> s) const {
        return false;
    }

    template<std::size_t N2>
    consteval CompTimeStr<N+N2-1> operator+(const CompTimeStr<N2> str) const {
        char newchar[N+N2-1] {};
        std::copy_n(data, N-1, newchar);
        std::copy_n(str.data, N2, newchar+N-1);
        return newchar;
    }

    consteval char operator[](std::size_t n) const {
        return data[n];
    }

    consteval std::size_t size() const {
        return N-1;
    }
};

template<std::size_t s1, std::size_t s2>
consteval auto operator+(CompTimeStr<s1> fs, const char (&str) [s2]) {
    return fs + CompTimeStr<s2>(str);
}

template<std::size_t s1, std::size_t s2>
consteval auto operator+(const char (&str) [s2], CompTimeStr<s1> fs) {
    return CompTimeStr<s2>(str) + fs;
}

template<std::size_t s1, std::size_t s2>
consteval auto operator==(CompTimeStr<s1> fs, const char (&str) [s2]) {
    return fs == CompTimeStr<s2>(str);
}

template<std::size_t s1, std::size_t s2>
consteval auto operator==(const char (&str) [s2], CompTimeStr<s1> fs) {
    return CompTimeStr<s2>(str) == fs;
}

This template will let us to operate over strings at compile time, we can compare and concatenate them at compile time.

Each time we concatenate strings it will return a new CompTimeStr<N>.

This lets us a world of possibilities, we could even create a search function to find specific words in our string and its position.

Usage example

This is a basic usage of CompTimeStr<N>



#include <iostream>

template<CompTimeStr str>
constexpr auto addBar() {
    return str + " bar";
}

constexpr CompTimeStr str = addBar<"foo">();

int main() {
    std::cout << str.data << std::endl;
    std::cout << std::boolalpha << (str == "foo bar") << std::endl;
}

The output will be:



foo bar
true

If we look at the non-optimized assembly output, we will find this:

We can see foo bar concatenated at compile time and (str == "foo bar") condition precalculated as well.

Foreach macro in C

Horu — Sat, 06 May 2023 01:02:55 +0000

There's times when we want to do weird things with macros like this:

#define PRINT(ARG) printf("%s\n", #ARG);

int main() {
    FOREACH(PRINT, foo, bar)
}

The output will be:

foo
bar

Basic steps

First we need to think how to start this challenge, in my last post I explained how to create a repeat macro which repeats N times whatever we want, I recommend you read it to understand this one. view post.

First we need to calculate the number of arguments, so then we will can repeat N times over it like we did with the repeat macro.

How to calculate the number of arguments?

We can start defining our N_VA_ARGS macro like this

#define N_VA_ARGS_(_9,_8,_7,_6,_5,_4,_3,_2,_1, N, ...) N
#define N_VA_ARGS(...) N_VA_ARGS_(__VA_ARGS__ __VA_OPT__(,) 9,8,7,6,5,4,3,2,1,0)

__VA_ARGS__ __VA_OPT__(,) will paste our arguments before the sequence, we will use __VA_OPT__(,) to set a comma if it is needed.
According how many arguments we pass, it will move the sequence to the right, in this case we have the sequence (9,8,7,6,5,4,3,2,1,0) so N_VA_ARGS_ will take the 0 when there's no arguments, then if we pass an argument the sequence will move to the right and N will be 1 in this case and 0 will be discarded by the .... So with this way we can calculate how many arguments we will pass to our foreach macro (only until 9 arguments).

The foreach macro

Once we have our N_VA_ARGS macro, it is time to build our foreach macro.

#define N_VA_ARGS_(_9,_8,_7,_6,_5,_4,_3,_2,_1, N, ...) N
#define N_VA_ARGS(...) N_VA_ARGS_(__VA_ARGS__ __VA_OPT__(,) 9,8,7,6,5,4,3,2,1,0)

#define FOREACH_0(FN, ...) 
#define FOREACH_1(FN, E, ...)  FN(E) 
#define FOREACH_2(FN, E, ...)  FN(E) FOREACH_1(FN, __VA_ARGS__)
#define FOREACH_3(FN, E, ...)  FN(E) FOREACH_2(FN, __VA_ARGS__)
#define FOREACH_4(FN, E, ...)  FN(E) FOREACH_3(FN, __VA_ARGS__)
#define FOREACH_5(FN, E, ...)  FN(E) FOREACH_4(FN, __VA_ARGS__)
#define FOREACH_6(FN, E, ...)  FN(E) FOREACH_5(FN, __VA_ARGS__)
#define FOREACH_7(FN, E, ...)  FN(E) FOREACH_6(FN, __VA_ARGS__)
#define FOREACH_8(FN, E, ...)  FN(E) FOREACH_7(FN, __VA_ARGS__)
#define FOREACH_9(FN, E, ...)  FN(E) FOREACH_8(FN, __VA_ARGS__)

#define FOREACH__(FN, NARGS, ...) FOREACH_##NARGS(FN, __VA_ARGS__) 
#define FOREACH_(FN, NARGS, ...) FOREACH__(FN, NARGS, __VA_ARGS__)
#define FOREACH(FN, ...) FOREACH_(FN, N_VA_ARGS(__VA_ARGS__), __VA_ARGS__)

FOREACH will calculate the number of arguments using N_VA_ARGS, and then will call FOREACH_X depending how many arguments we pass.

FOREACH_X will call recursively until reach FOREACH_1, every call will recursively grab the first argument and forward the rest to the next function always callling to FN macro.

Completed foreach macro

This is the completed version of foreach macro, it supports until 100 arguments.

#define N_VA_ARGS_(_100,_99,_98,_97,_96,_95,_94,_93,_92,_91,_90,_89,_88,_87,_86,_85,_84,_83,_82,_81,_80,_79,_78,_77,_76,_75,_74,_73,_72,_71,_70,_69,_68,_67,_66,_65,_64,_63,_62,_61,_60,_59,_58,_57,_56,_55,_54,_53,_52,_51,_50,_49,_48,_47,_46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1, N, ...) N
#define N_VA_ARGS(...) N_VA_ARGS_(__VA_ARGS__ __VA_OPT__(,) 100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0)

#define FOREACH_0(FN, ...) 
#define FOREACH_1(FN, E, ...) FN(E) 
#define FOREACH_2(FN, E, ...) FN(E) FOREACH_1(FN, __VA_ARGS__)
#define FOREACH_3(FN, E, ...) FN(E) FOREACH_2(FN, __VA_ARGS__)
#define FOREACH_4(FN, E, ...) FN(E) FOREACH_3(FN, __VA_ARGS__)
#define FOREACH_5(FN, E, ...) FN(E) FOREACH_4(FN, __VA_ARGS__)
#define FOREACH_6(FN, E, ...) FN(E) FOREACH_5(FN, __VA_ARGS__)
#define FOREACH_7(FN, E, ...) FN(E) FOREACH_6(FN, __VA_ARGS__)
#define FOREACH_8(FN, E, ...) FN(E) FOREACH_7(FN, __VA_ARGS__)
#define FOREACH_9(FN, E, ...) FN(E) FOREACH_8(FN, __VA_ARGS__)
#define FOREACH_10(FN, E, ...) FN(E) FOREACH_9(FN, __VA_ARGS__)
#define FOREACH_11(FN, E, ...) FN(E) FOREACH_10(FN, __VA_ARGS__)
#define FOREACH_12(FN, E, ...) FN(E) FOREACH_11(FN, __VA_ARGS__)
#define FOREACH_13(FN, E, ...) FN(E) FOREACH_12(FN, __VA_ARGS__)
#define FOREACH_14(FN, E, ...) FN(E) FOREACH_13(FN, __VA_ARGS__)
#define FOREACH_15(FN, E, ...) FN(E) FOREACH_14(FN, __VA_ARGS__)
#define FOREACH_16(FN, E, ...) FN(E) FOREACH_15(FN, __VA_ARGS__)
#define FOREACH_17(FN, E, ...) FN(E) FOREACH_16(FN, __VA_ARGS__)
#define FOREACH_18(FN, E, ...) FN(E) FOREACH_17(FN, __VA_ARGS__)
#define FOREACH_19(FN, E, ...) FN(E) FOREACH_18(FN, __VA_ARGS__)
#define FOREACH_20(FN, E, ...) FN(E) FOREACH_19(FN, __VA_ARGS__)
#define FOREACH_21(FN, E, ...) FN(E) FOREACH_20(FN, __VA_ARGS__)
#define FOREACH_22(FN, E, ...) FN(E) FOREACH_21(FN, __VA_ARGS__)
#define FOREACH_23(FN, E, ...) FN(E) FOREACH_22(FN, __VA_ARGS__)
#define FOREACH_24(FN, E, ...) FN(E) FOREACH_23(FN, __VA_ARGS__)
#define FOREACH_25(FN, E, ...) FN(E) FOREACH_24(FN, __VA_ARGS__)
#define FOREACH_26(FN, E, ...) FN(E) FOREACH_25(FN, __VA_ARGS__)
#define FOREACH_27(FN, E, ...) FN(E) FOREACH_26(FN, __VA_ARGS__)
#define FOREACH_28(FN, E, ...) FN(E) FOREACH_27(FN, __VA_ARGS__)
#define FOREACH_29(FN, E, ...) FN(E) FOREACH_28(FN, __VA_ARGS__)
#define FOREACH_30(FN, E, ...) FN(E) FOREACH_29(FN, __VA_ARGS__)
#define FOREACH_31(FN, E, ...) FN(E) FOREACH_30(FN, __VA_ARGS__)
#define FOREACH_32(FN, E, ...) FN(E) FOREACH_31(FN, __VA_ARGS__)
#define FOREACH_33(FN, E, ...) FN(E) FOREACH_32(FN, __VA_ARGS__)
#define FOREACH_34(FN, E, ...) FN(E) FOREACH_33(FN, __VA_ARGS__)
#define FOREACH_35(FN, E, ...) FN(E) FOREACH_34(FN, __VA_ARGS__)
#define FOREACH_36(FN, E, ...) FN(E) FOREACH_35(FN, __VA_ARGS__)
#define FOREACH_37(FN, E, ...) FN(E) FOREACH_36(FN, __VA_ARGS__)
#define FOREACH_38(FN, E, ...) FN(E) FOREACH_37(FN, __VA_ARGS__)
#define FOREACH_39(FN, E, ...) FN(E) FOREACH_38(FN, __VA_ARGS__)
#define FOREACH_40(FN, E, ...) FN(E) FOREACH_39(FN, __VA_ARGS__)
#define FOREACH_41(FN, E, ...) FN(E) FOREACH_40(FN, __VA_ARGS__)
#define FOREACH_42(FN, E, ...) FN(E) FOREACH_41(FN, __VA_ARGS__)
#define FOREACH_43(FN, E, ...) FN(E) FOREACH_42(FN, __VA_ARGS__)
#define FOREACH_44(FN, E, ...) FN(E) FOREACH_43(FN, __VA_ARGS__)
#define FOREACH_45(FN, E, ...) FN(E) FOREACH_44(FN, __VA_ARGS__)
#define FOREACH_46(FN, E, ...) FN(E) FOREACH_45(FN, __VA_ARGS__)
#define FOREACH_47(FN, E, ...) FN(E) FOREACH_46(FN, __VA_ARGS__)
#define FOREACH_48(FN, E, ...) FN(E) FOREACH_47(FN, __VA_ARGS__)
#define FOREACH_49(FN, E, ...) FN(E) FOREACH_48(FN, __VA_ARGS__)
#define FOREACH_50(FN, E, ...) FN(E) FOREACH_49(FN, __VA_ARGS__)
#define FOREACH_51(FN, E, ...) FN(E) FOREACH_50(FN, __VA_ARGS__)
#define FOREACH_52(FN, E, ...) FN(E) FOREACH_51(FN, __VA_ARGS__)
#define FOREACH_53(FN, E, ...) FN(E) FOREACH_52(FN, __VA_ARGS__)
#define FOREACH_54(FN, E, ...) FN(E) FOREACH_53(FN, __VA_ARGS__)
#define FOREACH_55(FN, E, ...) FN(E) FOREACH_54(FN, __VA_ARGS__)
#define FOREACH_56(FN, E, ...) FN(E) FOREACH_55(FN, __VA_ARGS__)
#define FOREACH_57(FN, E, ...) FN(E) FOREACH_56(FN, __VA_ARGS__)
#define FOREACH_58(FN, E, ...) FN(E) FOREACH_57(FN, __VA_ARGS__)
#define FOREACH_59(FN, E, ...) FN(E) FOREACH_58(FN, __VA_ARGS__)
#define FOREACH_60(FN, E, ...) FN(E) FOREACH_59(FN, __VA_ARGS__)
#define FOREACH_61(FN, E, ...) FN(E) FOREACH_60(FN, __VA_ARGS__)
#define FOREACH_62(FN, E, ...) FN(E) FOREACH_61(FN, __VA_ARGS__)
#define FOREACH_63(FN, E, ...) FN(E) FOREACH_62(FN, __VA_ARGS__)
#define FOREACH_64(FN, E, ...) FN(E) FOREACH_63(FN, __VA_ARGS__)
#define FOREACH_65(FN, E, ...) FN(E) FOREACH_64(FN, __VA_ARGS__)
#define FOREACH_66(FN, E, ...) FN(E) FOREACH_65(FN, __VA_ARGS__)
#define FOREACH_67(FN, E, ...) FN(E) FOREACH_66(FN, __VA_ARGS__)
#define FOREACH_68(FN, E, ...) FN(E) FOREACH_67(FN, __VA_ARGS__)
#define FOREACH_69(FN, E, ...) FN(E) FOREACH_68(FN, __VA_ARGS__)
#define FOREACH_70(FN, E, ...) FN(E) FOREACH_69(FN, __VA_ARGS__)
#define FOREACH_71(FN, E, ...) FN(E) FOREACH_70(FN, __VA_ARGS__)
#define FOREACH_72(FN, E, ...) FN(E) FOREACH_71(FN, __VA_ARGS__)
#define FOREACH_73(FN, E, ...) FN(E) FOREACH_72(FN, __VA_ARGS__)
#define FOREACH_74(FN, E, ...) FN(E) FOREACH_73(FN, __VA_ARGS__)
#define FOREACH_75(FN, E, ...) FN(E) FOREACH_74(FN, __VA_ARGS__)
#define FOREACH_76(FN, E, ...) FN(E) FOREACH_75(FN, __VA_ARGS__)
#define FOREACH_77(FN, E, ...) FN(E) FOREACH_76(FN, __VA_ARGS__)
#define FOREACH_78(FN, E, ...) FN(E) FOREACH_77(FN, __VA_ARGS__)
#define FOREACH_79(FN, E, ...) FN(E) FOREACH_78(FN, __VA_ARGS__)
#define FOREACH_80(FN, E, ...) FN(E) FOREACH_79(FN, __VA_ARGS__)
#define FOREACH_81(FN, E, ...) FN(E) FOREACH_80(FN, __VA_ARGS__)
#define FOREACH_82(FN, E, ...) FN(E) FOREACH_81(FN, __VA_ARGS__)
#define FOREACH_83(FN, E, ...) FN(E) FOREACH_82(FN, __VA_ARGS__)
#define FOREACH_84(FN, E, ...) FN(E) FOREACH_83(FN, __VA_ARGS__)
#define FOREACH_85(FN, E, ...) FN(E) FOREACH_84(FN, __VA_ARGS__)
#define FOREACH_86(FN, E, ...) FN(E) FOREACH_85(FN, __VA_ARGS__)
#define FOREACH_87(FN, E, ...) FN(E) FOREACH_86(FN, __VA_ARGS__)
#define FOREACH_88(FN, E, ...) FN(E) FOREACH_87(FN, __VA_ARGS__)
#define FOREACH_89(FN, E, ...) FN(E) FOREACH_88(FN, __VA_ARGS__)
#define FOREACH_90(FN, E, ...) FN(E) FOREACH_89(FN, __VA_ARGS__)
#define FOREACH_91(FN, E, ...) FN(E) FOREACH_90(FN, __VA_ARGS__)
#define FOREACH_92(FN, E, ...) FN(E) FOREACH_91(FN, __VA_ARGS__)
#define FOREACH_93(FN, E, ...) FN(E) FOREACH_92(FN, __VA_ARGS__)
#define FOREACH_94(FN, E, ...) FN(E) FOREACH_93(FN, __VA_ARGS__)
#define FOREACH_95(FN, E, ...) FN(E) FOREACH_94(FN, __VA_ARGS__)
#define FOREACH_96(FN, E, ...) FN(E) FOREACH_95(FN, __VA_ARGS__)
#define FOREACH_97(FN, E, ...) FN(E) FOREACH_96(FN, __VA_ARGS__)
#define FOREACH_98(FN, E, ...) FN(E) FOREACH_97(FN, __VA_ARGS__)
#define FOREACH_99(FN, E, ...) FN(E) FOREACH_98(FN, __VA_ARGS__)
#define FOREACH_100(FN, E, ...) FN(E) FOREACH_99(FN, __VA_ARGS__)

#define FOREACH__(FN, NARGS, ...) FOREACH_##NARGS(FN, __VA_ARGS__) 
#define FOREACH_(FN, NARGS, ...) FOREACH__(FN, NARGS, __VA_ARGS__)
#define FOREACH(FN, ...) FOREACH_(FN, N_VA_ARGS(__VA_ARGS__), __VA_ARGS__)

Repeat macro in C?

Horu — Sun, 30 Apr 2023 12:52:31 +0000

Sometimes we want to repeat something at compile time using C, although this sounds difficult to elaborate.
Trying I managed to elaborate the following example:



#include <stdio.h>

#define REPEAT_1(FN) FN(0)
#define REPEAT_2(FN) REPEAT_1(FN) FN(1)
#define REPEAT_3(FN) REPEAT_2(FN) FN(2)
#define REPEAT_4(FN) REPEAT_3(FN) FN(3)
#define REPEAT_5(FN) REPEAT_4(FN) FN(4)
#define REPEAT_6(FN) REPEAT_5(FN) FN(5)
#define REPEAT_7(FN) REPEAT_6(FN) FN(6)
#define REPEAT_8(FN) REPEAT_7(FN) FN(7)
#define REPEAT_9(FN) REPEAT_8(FN) FN(8)
#define REPEAT_10(FN) REPEAT_9(FN) FN(9)

#define REPEAT(FN, N) REPEAT_##N(FN)

#define PRINTF(N) printf("%d\n", N);

int main() {
    REPEAT(PRINTF, 10)
}

We will find the following output:

The main macro is called REPEAT, which takes a function/macro name and a loop count as its arguments. It then generates a call to one of the other macros (REPEAT_1, REPEAT_2, etc.) depending on the loop count.

Each of the REPEAT_X macros generates code for a loop that calls the specified function X times with different arguments. For example, REPEAT_5 generates a loop that calls the function 5 times with the arguments 0 through 4.

We can see the PRINTF macro calling printf with an integer argument. It then calls REPEAT with PRINTF and a loop count of 10, which generates code that calls printf 10 times with the arguments 0 through 9.

This will generate the assembly output we expect.

We will need to specify more REPEAT macros if we need repeating more than 10 times.

Here's the REPEAT macro which can repeat 100 times:



#define REPEAT_1(FN) FN(0)
#define REPEAT_2(FN) REPEAT_1(FN) FN(1)
#define REPEAT_3(FN) REPEAT_2(FN) FN(2)
#define REPEAT_4(FN) REPEAT_3(FN) FN(3)
#define REPEAT_5(FN) REPEAT_4(FN) FN(4)
#define REPEAT_6(FN) REPEAT_5(FN) FN(5)
#define REPEAT_7(FN) REPEAT_6(FN) FN(6)
#define REPEAT_8(FN) REPEAT_7(FN) FN(7)
#define REPEAT_9(FN) REPEAT_8(FN) FN(8)
#define REPEAT_10(FN) REPEAT_9(FN) FN(9)
#define REPEAT_11(FN) REPEAT_10(FN) FN(10)
#define REPEAT_12(FN) REPEAT_11(FN) FN(11)
#define REPEAT_13(FN) REPEAT_12(FN) FN(12)
#define REPEAT_14(FN) REPEAT_13(FN) FN(13)
#define REPEAT_15(FN) REPEAT_14(FN) FN(14)
#define REPEAT_16(FN) REPEAT_15(FN) FN(15)
#define REPEAT_17(FN) REPEAT_16(FN) FN(16)
#define REPEAT_18(FN) REPEAT_17(FN) FN(17)
#define REPEAT_19(FN) REPEAT_18(FN) FN(18)
#define REPEAT_20(FN) REPEAT_19(FN) FN(19)
#define REPEAT_21(FN) REPEAT_20(FN) FN(20)
#define REPEAT_22(FN) REPEAT_21(FN) FN(21)
#define REPEAT_23(FN) REPEAT_22(FN) FN(22)
#define REPEAT_24(FN) REPEAT_23(FN) FN(23)
#define REPEAT_25(FN) REPEAT_24(FN) FN(24)
#define REPEAT_26(FN) REPEAT_25(FN) FN(25)
#define REPEAT_27(FN) REPEAT_26(FN) FN(26)
#define REPEAT_28(FN) REPEAT_27(FN) FN(27)
#define REPEAT_29(FN) REPEAT_28(FN) FN(28)
#define REPEAT_30(FN) REPEAT_29(FN) FN(29)
#define REPEAT_31(FN) REPEAT_30(FN) FN(30)
#define REPEAT_32(FN) REPEAT_31(FN) FN(31)
#define REPEAT_33(FN) REPEAT_32(FN) FN(32)
#define REPEAT_34(FN) REPEAT_33(FN) FN(33)
#define REPEAT_35(FN) REPEAT_34(FN) FN(34)
#define REPEAT_36(FN) REPEAT_35(FN) FN(35)
#define REPEAT_37(FN) REPEAT_36(FN) FN(36)
#define REPEAT_38(FN) REPEAT_37(FN) FN(37)
#define REPEAT_39(FN) REPEAT_38(FN) FN(38)
#define REPEAT_40(FN) REPEAT_39(FN) FN(39)
#define REPEAT_41(FN) REPEAT_40(FN) FN(40)
#define REPEAT_42(FN) REPEAT_41(FN) FN(41)
#define REPEAT_43(FN) REPEAT_42(FN) FN(42)
#define REPEAT_44(FN) REPEAT_43(FN) FN(43)
#define REPEAT_45(FN) REPEAT_44(FN) FN(44)
#define REPEAT_46(FN) REPEAT_45(FN) FN(45)
#define REPEAT_47(FN) REPEAT_46(FN) FN(46)
#define REPEAT_48(FN) REPEAT_47(FN) FN(47)
#define REPEAT_49(FN) REPEAT_48(FN) FN(48)
#define REPEAT_50(FN) REPEAT_49(FN) FN(49)
#define REPEAT_51(FN) REPEAT_50(FN) FN(50)
#define REPEAT_52(FN) REPEAT_51(FN) FN(51)
#define REPEAT_53(FN) REPEAT_52(FN) FN(52)
#define REPEAT_54(FN) REPEAT_53(FN) FN(53)
#define REPEAT_55(FN) REPEAT_54(FN) FN(54)
#define REPEAT_56(FN) REPEAT_55(FN) FN(55)
#define REPEAT_57(FN) REPEAT_56(FN) FN(56)
#define REPEAT_58(FN) REPEAT_57(FN) FN(57)
#define REPEAT_59(FN) REPEAT_58(FN) FN(58)
#define REPEAT_60(FN) REPEAT_59(FN) FN(59)
#define REPEAT_61(FN) REPEAT_60(FN) FN(60)
#define REPEAT_62(FN) REPEAT_61(FN) FN(61)
#define REPEAT_63(FN) REPEAT_62(FN) FN(62)
#define REPEAT_64(FN) REPEAT_63(FN) FN(63)
#define REPEAT_65(FN) REPEAT_64(FN) FN(64)
#define REPEAT_66(FN) REPEAT_65(FN) FN(65)
#define REPEAT_67(FN) REPEAT_66(FN) FN(66)
#define REPEAT_68(FN) REPEAT_67(FN) FN(67)
#define REPEAT_69(FN) REPEAT_68(FN) FN(68)
#define REPEAT_70(FN) REPEAT_69(FN) FN(69)
#define REPEAT_71(FN) REPEAT_70(FN) FN(70)
#define REPEAT_72(FN) REPEAT_71(FN) FN(71)
#define REPEAT_73(FN) REPEAT_72(FN) FN(72)
#define REPEAT_74(FN) REPEAT_73(FN) FN(73)
#define REPEAT_75(FN) REPEAT_74(FN) FN(74)
#define REPEAT_76(FN) REPEAT_75(FN) FN(75)
#define REPEAT_77(FN) REPEAT_76(FN) FN(76)
#define REPEAT_78(FN) REPEAT_77(FN) FN(77)
#define REPEAT_79(FN) REPEAT_78(FN) FN(78)
#define REPEAT_80(FN) REPEAT_79(FN) FN(79)
#define REPEAT_81(FN) REPEAT_80(FN) FN(80)
#define REPEAT_82(FN) REPEAT_81(FN) FN(81)
#define REPEAT_83(FN) REPEAT_82(FN) FN(82)
#define REPEAT_84(FN) REPEAT_83(FN) FN(83)
#define REPEAT_85(FN) REPEAT_84(FN) FN(84)
#define REPEAT_86(FN) REPEAT_85(FN) FN(85)
#define REPEAT_87(FN) REPEAT_86(FN) FN(86)
#define REPEAT_88(FN) REPEAT_87(FN) FN(87)
#define REPEAT_89(FN) REPEAT_88(FN) FN(88)
#define REPEAT_90(FN) REPEAT_89(FN) FN(89)
#define REPEAT_91(FN) REPEAT_90(FN) FN(90)
#define REPEAT_92(FN) REPEAT_91(FN) FN(91)
#define REPEAT_93(FN) REPEAT_92(FN) FN(92)
#define REPEAT_94(FN) REPEAT_93(FN) FN(93)
#define REPEAT_95(FN) REPEAT_94(FN) FN(94)
#define REPEAT_96(FN) REPEAT_95(FN) FN(95)
#define REPEAT_97(FN) REPEAT_96(FN) FN(96)
#define REPEAT_98(FN) REPEAT_97(FN) FN(97)
#define REPEAT_99(FN) REPEAT_98(FN) FN(98)
#define REPEAT_100(FN) REPEAT_99(FN) FN(99)

#define REPEAT(FN, N) REPEAT_##N(FN)