diff options
| author | 2026-02-23 20:36:05 +0100 | |
|---|---|---|
| committer | 2026-02-23 20:36:05 +0100 | |
| commit | 052144cabb126efe925a96f8a0597a0f2005d206 (patch) | |
| tree | 4fd87244b9eef018b30e90fdff24c5b1a145a85e /test/external/metalang99/include | |
| parent | 4e9020dfb847d80475415f9f5914efaa50238767 (diff) | |
add metalang99 testsuite (preprocessor stress testing)
Diffstat (limited to 'test/external/metalang99/include')
31 files changed, 8552 insertions, 0 deletions
diff --git a/test/external/metalang99/include/metalang99.h b/test/external/metalang99/include/metalang99.h new file mode 100644 index 0000000..714c525 --- /dev/null +++ b/test/external/metalang99/include/metalang99.h @@ -0,0 +1,33 @@ +#ifndef ML99_H +#define ML99_H + +#if defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL +#error Please, specify /Zc:preprocessor to enable a standard-compliant C99/C++11 preprocessor. +#endif + +#include <metalang99/assert.h> +#include <metalang99/bool.h> +#include <metalang99/choice.h> +#include <metalang99/either.h> +#include <metalang99/gen.h> +#include <metalang99/ident.h> +#include <metalang99/lang.h> +#include <metalang99/list.h> +#include <metalang99/maybe.h> +#include <metalang99/nat.h> +#include <metalang99/seq.h> +#include <metalang99/stmt.h> +#include <metalang99/tuple.h> +#include <metalang99/util.h> +#include <metalang99/variadics.h> + +#define ML99_MAJOR 1 +#define ML99_MINOR 13 +#define ML99_PATCH 5 + +#define ML99_VERSION_COMPATIBLE(x, y, z) \ + (ML99_MAJOR == (x) && ((ML99_MINOR == (y) && ML99_PATCH >= (z)) || (ML99_MINOR > (y)))) + +#define ML99_VERSION_EQ(x, y, z) (ML99_MAJOR == (x) && ML99_MINOR == (y) && ML99_PATCH == (z)) + +#endif // ML99_H diff --git a/test/external/metalang99/include/metalang99/assert.h b/test/external/metalang99/include/metalang99/assert.h new file mode 100644 index 0000000..bbaa89b --- /dev/null +++ b/test/external/metalang99/include/metalang99/assert.h @@ -0,0 +1,134 @@ +/** + * @file + * Static assertions. + * + * For the sake of convenience, this header automatically includes `metalang99/bool.h`. + * + * @note [C99] Any of the following assertion macros must **not** appear on the same line number + * twice with itself as well as with any other Metalang99 assertion macro. + * @note [C11] The following assertion macros expand to `_Static_assert` and, therefore, can be used + * on the same line twice. + */ + +#ifndef ML99_ASSERT_H +#define ML99_ASSERT_H + +#include <metalang99/priv/compiler_specific.h> + +#include <metalang99/bool.h> +#include <metalang99/lang.h> + +/** + * The same as #ML99_ASSERT but results in a Metalang99 term. + * + * It can be used inside other Metalang99-compliant macros, unlike #ML99_ASSERT, which uses + * #ML99_EVAL internally. + */ +#define ML99_assert(expr) ML99_call(ML99_assert, expr) + +/** + * Like #ML99_assert but compares @p lhs with @p rhs for equality (`==`). + */ +#define ML99_assertEq(lhs, rhs) ML99_call(ML99_assertEq, lhs, rhs) + +/** + * Asserts `ML99_EVAL(expr)` at compile-time. + * + * # Examples + * + * @code + * #include <metalang99/assert.h> + * + * ML99_ASSERT(v(123 == 123)); + * @endcode + */ +#define ML99_ASSERT(expr) ML99_ASSERT_EQ(expr, ML99_true()) + +/** + * Asserts `ML99_EVAL(lhs) == ML99_EVAL(rhs)` at compile-time. + * + * # Examples + * + * @code + * #include <metalang99/assert.h> + * + * ML99_ASSERT_EQ(v(123), v(123)); + * @endcode + */ +#define ML99_ASSERT_EQ(lhs, rhs) ML99_ASSERT_UNEVAL((ML99_EVAL(lhs)) == (ML99_EVAL(rhs))) + +/** + * Asserts the C constant expression @p expr; + * [static_assert](https://en.cppreference.com/w/c/error/static_assert) in pure C99. + * + * # Examples + * + * @code + * #include <metalang99/assert.h> + * + * ML99_ASSERT_UNEVAL(123 == 123); + * @endcode + */ +#define ML99_ASSERT_UNEVAL(expr) ML99_PRIV_ASSERT_UNEVAL_INNER(expr) + +/** + * Asserts that `ML99_EVAL(expr)` is emptiness. + * + * # Examples + * + * @code + * #include <metalang99/assert.h> + * + * // Passes: + * ML99_ASSERT_EMPTY(v()); + * + * // Fails: + * ML99_ASSERT_EMPTY(v(123)); + * @endcode + */ +#define ML99_ASSERT_EMPTY(expr) ML99_ASSERT_EMPTY_UNEVAL(ML99_EVAL(expr)) + +/** + * Asserts that @p expr is emptiness. + * + * # Examples + * + * @code + * #include <metalang99/assert.h> + * + * // Passes: + * ML99_ASSERT_EMPTY_UNEVAL(); + * + * // Fails: + * ML99_ASSERT_EMPTY_UNEVAL(123); + * @endcode + */ +#define ML99_ASSERT_EMPTY_UNEVAL(expr) \ + ML99_ASSERT_UNEVAL(ML99_PRIV_CAT(ML99_PRIV_ASSERT_EMPTY_, expr)) + +#ifndef DOXYGEN_IGNORE + +#define ML99_assert_IMPL(expr) v(ML99_ASSERT_UNEVAL(expr)) +#define ML99_assertEq_IMPL(lhs, rhs) v(ML99_ASSERT_UNEVAL((lhs) == (rhs))) + +#ifdef ML99_PRIV_C11_STATIC_ASSERT_AVAILABLE +#define ML99_PRIV_ASSERT_UNEVAL_INNER(expr) _Static_assert((expr), "Metalang99 assertion failed") +#else +// How to imitate static assertions in C99: <https://stackoverflow.com/a/3385694/13166656>. +#define ML99_PRIV_ASSERT_UNEVAL_INNER(expr) \ + static const char ML99_PRIV_CAT( \ + ml99_assert_, \ + __LINE__)[(expr) ? 1 : -1] ML99_PRIV_COMPILER_ATTR_UNUSED = {0} +#endif + +#define ML99_PRIV_ASSERT_EMPTY_ 1 + +// Arity specifiers { + +#define ML99_assert_ARITY 1 +#define ML99_assertEq_ARITY 2 +// } (Arity specifiers) + +#endif // DOXYGEN_IGNORE + +#endif // ML99_ASSERT_H diff --git a/test/external/metalang99/include/metalang99/bool.h b/test/external/metalang99/include/metalang99/bool.h new file mode 100644 index 0000000..0213cb2 --- /dev/null +++ b/test/external/metalang99/include/metalang99/bool.h @@ -0,0 +1,246 @@ +/** + * @file + * Boolean algebra. + */ + +#ifndef ML99_BOOL_H +#define ML99_BOOL_H + +#include <metalang99/priv/bool.h> +#include <metalang99/priv/tuple.h> + +#include <metalang99/lang.h> + +/** + * Truth. + */ +#define ML99_true(...) ML99_callUneval(ML99_true, ) + +/** + * Falsehood. + */ +#define ML99_false(...) ML99_callUneval(ML99_false, ) + +/** + * Logical negation. + * + * # Examples + * + * @code + * #include <metalang99/bool.h> + * + * // 1 + * ML99_not(v(0)) + * + * // 0 + * ML99_not(v(1)) + * @endcode + */ +#define ML99_not(x) ML99_call(ML99_not, x) + +/** + * Logical conjunction. + * + * # Examples + * + * @code + * #include <metalang99/bool.h> + * + * // 0 + * ML99_and(v(0), v(0)) + * + * // 0 + * ML99_and(v(0), v(1)) + * + * // 0 + * ML99_and(v(1), v(0)) + * + * // 1 + * ML99_and(v(1), v(1)) + * @endcode + */ +#define ML99_and(x, y) ML99_call(ML99_and, x, y) + +/** + * Logical inclusive OR. + * + * # Examples + * @code + * #include <metalang99/bool.h> + * + * // 0 + * ML99_or(v(0), v(0)) + * + * // 1 + * ML99_or(v(0), v(1)) + * + * // 1 + * ML99_or(v(1), v(0)) + * + * // 1 + * ML99_or(v(1), v(1)) + * @endcode + */ +#define ML99_or(x, y) ML99_call(ML99_or, x, y) + +/** + * Logical exclusive OR. + * + * # Examples + * + * @code + * #include <metalang99/bool.h> + * + * // 0 + * ML99_xor(v(0), v(0)) + * + * // 1 + * ML99_xor(v(0), v(1)) + * + * // 1 + * ML99_xor(v(1), v(0)) + * + * // 0 + * ML99_xor(v(1), v(1)) + * @endcode + */ +#define ML99_xor(x, y) ML99_call(ML99_xor, x, y) + +/** + * Tests @p x and @p y for equality. + * + * # Examples + * + * @code + * #include <metalang99/bool.h> + * + * // 1 + * ML99_boolEq(v(0), v(0)) + * + * // 0 + * ML99_boolEq(v(0), v(1)) + * + * // 0 + * ML99_boolEq(v(1), v(0)) + * + * // 1 + * ML99_boolEq(v(1), v(1)) + * @endcode + */ +#define ML99_boolEq(x, y) ML99_call(ML99_boolEq, x, y) + +/** + * Matches @p x against the two cases: if it is 0 or 1. + * + * # Examples + * + * @code + * #include <metalang99/bool.h> + * + * #define MATCH_1_IMPL() v(Billie) + * #define MATCH_0_IMPL() v(Jean) + * + * // Billie + * ML99_boolMatch(v(1), v(MATCH_)) + * + * // Jean + * ML99_boolMatch(v(0), v(MATCH_)) + * @endcode + * + * @note This function calls @p f with #ML99_call, so no partial application occurs, and so + * arity specifiers are not needed. + */ +#define ML99_boolMatch(x, matcher) ML99_call(ML99_boolMatch, x, matcher) + +/** + * The same as #ML99_boolMatch but provides additional arguments to all branches. + * + * # Examples + * + * @code + * #include <metalang99/bool.h> + * + * #define MATCH_1_IMPL(x, y, z) v(Billie ~ x y z) + * #define MATCH_0_IMPL(x, y, z) v(Jean ~ x y z) + * + * // Billie ~ 1 2 3 + * ML99_boolMatchWithArgs(v(1), v(MATCH_), v(1, 2, 3)) + * + * // Jean ~ 1 2 3 + * ML99_boolMatchWithArgs(v(0), v(MATCH_), v(1, 2, 3)) + * @endcode + */ +#define ML99_boolMatchWithArgs(x, matcher, ...) \ + ML99_call(ML99_boolMatchWithArgs, x, matcher, __VA_ARGS__) + +/** + * If @p cond is true, evaluates to @p x, otherwise @p y. + * + * # Examples + * + * @code + * #include <metalang99/bool.h> + * + * // 123 + * ML99_if(v(1), v(123), v(18)) + * + * // 18 + * ML99_if(v(0), v(123), v(18)) + * @endcode + */ +#define ML99_if(cond, x, y) ML99_call(ML99_if, cond, x, y) + +/** + * The plain version of #ML99_if. + * + * This macro can imitate lazy evaluation: `ML99_IF(<cond>, <term>, <another-term>)` will expand to + * one of the two terms, which can be evaluated further; if `<cond>` is 0, then `<term>` will + * **not** be evaluated, and the same with `<another-term>`. + * + * @note @p x and @p y can possibly expand to commas. It means that you can supply `ML99_TERMS(...)` + * as a branch, for example. + */ +#define ML99_IF(cond, x, y) ML99_PRIV_UNTUPLE(ML99_PRIV_IF(cond, (x), (y))) + +#define ML99_TRUE(...) 1 +#define ML99_FALSE(...) 0 + +#define ML99_NOT(x) ML99_PRIV_NOT(x) +#define ML99_AND(x, y) ML99_PRIV_AND(x, y) +#define ML99_OR(x, y) ML99_PRIV_OR(x, y) +#define ML99_XOR(x, y) ML99_PRIV_XOR(x, y) +#define ML99_BOOL_EQ(x, y) ML99_PRIV_BOOL_EQ(x, y) + +#ifndef DOXYGEN_IGNORE + +#define ML99_true_IMPL(...) v(ML99_TRUE()) +#define ML99_false_IMPL(...) v(ML99_FALSE()) + +#define ML99_not_IMPL(x) v(ML99_NOT(x)) +#define ML99_and_IMPL(x, y) v(ML99_AND(x, y)) +#define ML99_or_IMPL(x, y) v(ML99_OR(x, y)) +#define ML99_xor_IMPL(x, y) v(ML99_XOR(x, y)) +#define ML99_boolEq_IMPL(x, y) v(ML99_BOOL_EQ(x, y)) + +#define ML99_boolMatch_IMPL(x, matcher) ML99_callUneval(matcher##x, ) +#define ML99_boolMatchWithArgs_IMPL(x, matcher, ...) ML99_callUneval(matcher##x, __VA_ARGS__) + +#define ML99_if_IMPL(cond, x, y) v(ML99_PRIV_IF(cond, x, y)) + +// Arity specifiers { + +#define ML99_true_ARITY 1 +#define ML99_false_ARITY 1 +#define ML99_not_ARITY 1 +#define ML99_and_ARITY 2 +#define ML99_or_ARITY 2 +#define ML99_xor_ARITY 2 +#define ML99_boolEq_ARITY 2 +#define ML99_boolMatch_ARITY 2 +#define ML99_boolMatchWithArgs_ARITY 3 +#define ML99_if_ARITY 3 +// } (Arity specifiers) + +#endif // DOXYGEN_IGNORE + +#endif // ML99_BOOL_H diff --git a/test/external/metalang99/include/metalang99/choice.h b/test/external/metalang99/include/metalang99/choice.h new file mode 100644 index 0000000..fcdcf07 --- /dev/null +++ b/test/external/metalang99/include/metalang99/choice.h @@ -0,0 +1,129 @@ +/** + * @file + * Choice types: `(tag, ...)`. + * + * A choice type, also known as [tagged union], is represented as `(tag, ...)`, where `tag` is the + * type of a value and `...` is the value. Perhaps the most common example of a choice type is a + * binary tree: + * + * [[examples/binary_tree.c](https://github.com/hirrolot/metalang99/blob/master/examples/binary_tree.c)] + * @include binary_tree.c + * + * [tagged union]: https://en.wikipedia.org/wiki/Tagged_union + */ + +#ifndef ML99_CHOICE_H +#define ML99_CHOICE_H + +#include <metalang99/priv/util.h> + +#include <metalang99/lang.h> + +/** + * Constructs an instance of a choice type. + * + * # Examples + * + * See + * [examples/binary_tree.c](https://github.com/hirrolot/metalang99/blob/master/examples/binary_tree.c). + * + * @note Specify `~` if you do not want to supply data; then, to match it, write a `_` parameter to + * ignore. + */ +#define ML99_choice(tag, ...) ML99_call(ML99_choice, tag, __VA_ARGS__) + +/** + * Evaluates to the tag of @p choice. + * + * This macro is essentially the same as `ML99_tupleGet(0)`. + * + * # Examples + * + * @code + * #include <metalang99/choice.h> + * + * // foo + * ML99_choiceTag(ML99_choice(v(foo), v(1, 2, 3))) + * @endcode + */ +#define ML99_choiceTag(choice) ML99_call(ML99_choiceTag, choice) + +/** + * Evaluates to the data of @p choice. + * + * This macro is essentially the same as #ML99_tupleTail. + * + * # Examples + * + * @code + * #include <metalang99/choice.h> + * + * // 1, 2, 3 + * ML99_choiceData(ML99_choice(v(foo), v(1, 2, 3))) + * @endcode + */ +#define ML99_choiceData(choice) ML99_call(ML99_choiceData, choice) + +/** + * Matches the instance @p choice of a choice type. + * + * This macro results in `ML99_call(ML99_cat(matcher, ML99_choiceTag(choice)), <choice data>)`. + * + * # Examples + * + * See + * [examples/binary_tree.c](https://github.com/hirrolot/metalang99/blob/master/examples/binary_tree.c). + */ +#define ML99_match(choice, matcher) ML99_call(ML99_match, choice, matcher) + +/** + * The same as #ML99_match but supplies additional arguments to all branches. + * + * This macro results in `ML99_call(ML99_cat(matcher, ML99_choiceTag(choice)), <choice data>, + * args...)`. + * + * # Examples + * + * @code + * #include <metalang99/choice.h> + * + * #define MATCH_A_IMPL(x, y, z) v(x ~ y ~ z) + * + * // 123 ~ 456 ~ 789 + * ML99_matchWithArgs(ML99_choice(v(A), v(123)), v(MATCH_), v(456, 789)) + * @endcode + */ +#define ML99_matchWithArgs(choice, matcher, ...) \ + ML99_call(ML99_matchWithArgs, choice, matcher, __VA_ARGS__) + +#define ML99_CHOICE(tag, ...) (tag, __VA_ARGS__) +#define ML99_CHOICE_TAG(choice) ML99_PRIV_HEAD_AUX choice +#define ML99_CHOICE_DATA(choice) ML99_PRIV_TAIL_AUX choice + +#ifndef DOXYGEN_IGNORE + +#define ML99_choice_IMPL(tag, ...) v(ML99_CHOICE(tag, __VA_ARGS__)) +#define ML99_choiceTag_IMPL(choice) v(ML99_CHOICE_TAG(choice)) +#define ML99_choiceData_IMPL(choice) v(ML99_CHOICE_DATA(choice)) + +#define ML99_match_IMPL(choice, matcher) \ + ML99_callUneval(ML99_PRIV_CAT(matcher, ML99_PRIV_HEAD_AUX choice), ML99_PRIV_TAIL_AUX choice) + +#define ML99_matchWithArgs_IMPL(choice, matcher, ...) \ + ML99_callUneval( \ + ML99_PRIV_CAT(matcher, ML99_PRIV_HEAD_AUX choice), \ + ML99_PRIV_TAIL_AUX choice, \ + __VA_ARGS__) + +// Arity specifiers { + +#define ML99_choice_ARITY 2 +#define ML99_choiceTag_ARITY 1 +#define ML99_choiceData_ARITY 1 +#define ML99_match_ARITY 2 +#define ML99_matchWithArgs_ARITY 3 +// } (Arity specifiers) + +#endif // DOXYGEN_IGNORE + +#endif // ML99_CHOICE_H diff --git a/test/external/metalang99/include/metalang99/control.h b/test/external/metalang99/include/metalang99/control.h new file mode 100644 index 0000000..13ed33b --- /dev/null +++ b/test/external/metalang99/include/metalang99/control.h @@ -0,0 +1,13 @@ +/** + * @file + * This module is deprecated and exists only for backwards compatibility. + */ + +#ifndef ML99_CONTROL_H +#define ML99_CONTROL_H + +#include <metalang99/bool.h> // ML99_if, ML99_IF +#include <metalang99/gen.h> // ML99_times, ML99_repeat +#include <metalang99/variadics.h> // ML99_OVERLOAD + +#endif // ML99_CONTROL_H diff --git a/test/external/metalang99/include/metalang99/either.h b/test/external/metalang99/include/metalang99/either.h new file mode 100644 index 0000000..c3b7732 --- /dev/null +++ b/test/external/metalang99/include/metalang99/either.h @@ -0,0 +1,170 @@ +/** + * @file + * A choice type with two cases. + */ + +#ifndef ML99_EITHER_H +#define ML99_EITHER_H + +#include <metalang99/priv/util.h> + +#include <metalang99/bool.h> +#include <metalang99/choice.h> +#include <metalang99/ident.h> + +/** + * The left value @p x. + */ +#define ML99_left(x) ML99_call(ML99_left, x) + +/** + * The right value @p x. + */ +#define ML99_right(x) ML99_call(ML99_right, x) + +/** + * `ML99_true()` if @p either contains a left value, otherwise `ML99_false()`. + * + * # Examples + * + * @code + * #include <metalang99/either.h> + * + * // 1 + * ML99_isLeft(ML99_left(v(123))) + * + * // 0 + * ML99_isLeft(ML99_right(v(123))) + * @endcode + */ +#define ML99_isLeft(either) ML99_call(ML99_isLeft, either) + +/** + * The inverse of #ML99_isLeft. + * + * # Examples + * + * @code + * #include <metalang99/either.h> + * + * // 1 + * ML99_isRight(ML99_right(v(123))) + * + * // 0 + * ML99_isRight(ML99_left(v(123))) + * @endcode + */ +#define ML99_isRight(either) ML99_call(ML99_isRight, either) + +/** + * Tests @p either and @p other for equality. + * + * # Examples + * + * @code + * #include <metalang99/either.h> + * #include <metalang99/nat.h> + * + * // 1 + * ML99_eitherEq(v(ML99_natEq), ML99_left(v(123)), ML99_left(v(123))) + * + * // 0 + * ML99_eitherEq(v(ML99_natEq), ML99_right(v(123)), ML99_left(v(8))) + * + * // 0 + * ML99_eitherEq(v(ML99_natEq), ML99_right(v(123)), ML99_left(v(123))) + * @endcode + */ +#define ML99_eitherEq(cmp, either, other) ML99_call(ML99_eitherEq, cmp, either, other) + +/** + * Returns the left value on `ML99_left(x)` or emits a fatal error on `ML99_right(y)`. + * + * # Examples + * + * @code + * #include <metalang99/either.h> + * + * // 123 + * ML99_unwrapLeft(ML99_left(v(123))) + * + * // Emits a fatal error. + * ML99_unwrapLeft(ML99_right(v(123))) + * @endcode + */ +#define ML99_unwrapLeft(either) ML99_call(ML99_unwrapLeft, either) + +/** + * The inverse of #ML99_unwrapLeft. + * + * # Examples + * + * @code + * #include <metalang99/either.h> + * + * // 123 + * ML99_unwrapRight(ML99_right(v(123))) + * + * // Emits a fatal error. + * ML99_unwrapRight(ML99_left(v(123))) + * @endcode + */ +#define ML99_unwrapRight(either) ML99_call(ML99_unwrapRight, either) + +#define ML99_LEFT(x) ML99_CHOICE(left, x) +#define ML99_RIGHT(x) ML99_CHOICE(right, x) +#define ML99_IS_LEFT(either) ML99_PRIV_IS_LEFT(either) +#define ML99_IS_RIGHT(either) ML99_NOT(ML99_IS_LEFT(either)) + +#ifndef DOXYGEN_IGNORE + +#define ML99_left_IMPL(x) v(ML99_LEFT(x)) +#define ML99_right_IMPL(x) v(ML99_RIGHT(x)) + +#define ML99_isLeft_IMPL(either) v(ML99_IS_LEFT(either)) +#define ML99_isRight_IMPL(either) v(ML99_IS_RIGHT(either)) + +// ML99_eitherEq_IMPL { + +#define ML99_eitherEq_IMPL(cmp, either, other) \ + ML99_matchWithArgs_IMPL(either, ML99_PRIV_eitherEq_, cmp, other) + +#define ML99_PRIV_eitherEq_left_IMPL(x, cmp, other) \ + ML99_matchWithArgs_IMPL(other, ML99_PRIV_eitherEq_left_, cmp, x) +#define ML99_PRIV_eitherEq_right_IMPL(x, cmp, other) \ + ML99_matchWithArgs_IMPL(other, ML99_PRIV_eitherEq_right_, cmp, x) + +#define ML99_PRIV_eitherEq_left_left_IMPL(y, cmp, x) ML99_appl2_IMPL(cmp, x, y) +#define ML99_PRIV_eitherEq_left_right_IMPL ML99_false_IMPL + +#define ML99_PRIV_eitherEq_right_left_IMPL ML99_false_IMPL +#define ML99_PRIV_eitherEq_right_right_IMPL(y, cmp, x) ML99_appl2_IMPL(cmp, x, y) +// } (ML99_eitherEq_IMPL) + +#define ML99_unwrapLeft_IMPL(either) ML99_match_IMPL(either, ML99_PRIV_unwrapLeft_) +#define ML99_PRIV_unwrapLeft_left_IMPL(x) v(x) +#define ML99_PRIV_unwrapLeft_right_IMPL(_x) \ + ML99_fatal(ML99_unwrapLeft, expected ML99_left but found ML99_right) + +#define ML99_unwrapRight_IMPL(either) ML99_match_IMPL(either, ML99_PRIV_unwrapRight_) +#define ML99_PRIV_unwrapRight_left_IMPL(_x) \ + ML99_fatal(ML99_unwrapRight, expected ML99_right but found ML99_left) +#define ML99_PRIV_unwrapRight_right_IMPL(x) v(x) + +#define ML99_PRIV_IS_LEFT(either) ML99_DETECT_IDENT(ML99_PRIV_IS_LEFT_, ML99_CHOICE_TAG(either)) +#define ML99_PRIV_IS_LEFT_left () + +// Arity specifiers { + +#define ML99_left_ARITY 1 +#define ML99_right_ARITY 1 +#define ML99_isLeft_ARITY 1 +#define ML99_isRight_ARITY 1 +#define ML99_eitherEq_ARITY 3 +#define ML99_unwrapLeft_ARITY 1 +#define ML99_unwrapRight_ARITY 1 +// } (Arity specifiers) + +#endif // DOXYGEN_IGNORE + +#endif // ML99_EITHER_H diff --git a/test/external/metalang99/include/metalang99/eval/acc.h b/test/external/metalang99/include/metalang99/eval/acc.h new file mode 100644 index 0000000..cd284f2 --- /dev/null +++ b/test/external/metalang99/include/metalang99/eval/acc.h @@ -0,0 +1,14 @@ +#ifndef ML99_EVAL_ACC_H +#define ML99_EVAL_ACC_H + +#include <metalang99/priv/util.h> + +#define ML99_PRIV_EVAL_ACC (, ) +#define ML99_PRIV_EVAL_ACC_COMMA_SEP () + +#define ML99_PRIV_EVAL_0fspace(acc, ...) (ML99_PRIV_EXPAND acc __VA_ARGS__) +#define ML99_PRIV_EVAL_0fcomma(acc, ...) (ML99_PRIV_EXPAND acc, __VA_ARGS__) + +#define ML99_PRIV_EVAL_ACC_UNWRAP(_emptiness, ...) __VA_ARGS__ + +#endif // ML99_EVAL_ACC_H diff --git a/test/external/metalang99/include/metalang99/eval/eval.h b/test/external/metalang99/include/metalang99/eval/eval.h new file mode 100644 index 0000000..394a1e2 --- /dev/null +++ b/test/external/metalang99/include/metalang99/eval/eval.h @@ -0,0 +1,130 @@ +#ifndef ML99_EVAL_EVAL_H +#define ML99_EVAL_EVAL_H + +// Explanation is in the spec: <https://github.com/hirrolot/metalang99/blob/master/spec/spec.pdf>. + +#include <metalang99/priv/compiler_specific.h> +#include <metalang99/priv/util.h> + +#include <metalang99/eval/acc.h> +#include <metalang99/eval/rec.h> +#include <metalang99/eval/syntax_checker.h> + +#define ML99_PRIV_EVAL(...) \ + ML99_PRIV_REC_UNROLL(ML99_PRIV_EVAL_MATCH( \ + ML99_PRIV_REC_STOP, \ + (~), \ + 0fspace, \ + ML99_PRIV_EVAL_ACC, \ + __VA_ARGS__, \ + (0end, ~), \ + ~)) + +// Recursion hooks { + +#define ML99_PRIV_EVAL_MATCH_HOOK() ML99_PRIV_EVAL_MATCH +#define ML99_PRIV_EVAL_0v_K_HOOK() ML99_PRIV_EVAL_0v_K +#define ML99_PRIV_EVAL_0args_K_HOOK() ML99_PRIV_EVAL_0args_K +#define ML99_PRIV_EVAL_0op_K_HOOK() ML99_PRIV_EVAL_0op_K +#define ML99_PRIV_EVAL_0callUneval_K_HOOK() ML99_PRIV_EVAL_0callUneval_K +// } (Recursion hooks) + +#define ML99_PRIV_EVAL_MATCH(k, k_cx, folder, acc, head, ...) \ + ML99_PRIV_CHECK_TERM(head, ML99_PRIV_TERM_MATCH) \ + (head)(k, k_cx, folder, acc, (__VA_ARGS__), ML99_PRIV_TERM_DATA head) + +#define ML99_PRIV_TERM_MATCH(term) ML99_PRIV_CAT(ML99_PRIV_EVAL_, ML99_PRIV_TERM_KIND term) +#define ML99_PRIV_TERM_KIND(kind, ...) kind +#define ML99_PRIV_TERM_DATA(_kind, ...) __VA_ARGS__ + +// Reduction rules { + +#define ML99_PRIV_EVAL_0v ML99_PRIV_REC_CONTINUE(ML99_PRIV_EVAL_0v_K) +#define ML99_PRIV_EVAL_0args ML99_PRIV_REC_CONTINUE(ML99_PRIV_EVAL_0args_K) +#define ML99_PRIV_EVAL_0op ML99_PRIV_REC_CONTINUE(ML99_PRIV_EVAL_0op_K) +#define ML99_PRIV_EVAL_0callUneval ML99_PRIV_REC_CONTINUE(ML99_PRIV_EVAL_0callUneval_K) + +#define ML99_PRIV_EVAL_0fatal(...) ML99_PRIV_EVAL_0fatal_AUX(__VA_ARGS__) +#define ML99_PRIV_EVAL_0fatal_AUX(_k, _k_cx, _folder, _acc, _tail, f, message) \ + ML99_PRIV_REC_CONTINUE(ML99_PRIV_REC_STOP)((~), ML99_PRIV_FATAL_ERROR(f, message)) + +#ifdef ML99_PRIV_EMIT_ERROR +#define ML99_PRIV_FATAL_ERROR(f, message) ML99_PRIV_EMIT_ERROR(#f ": " message); +#else +// clang-format off +#define ML99_PRIV_FATAL_ERROR(f, message) !"Metalang99 error" (f): message +// clang-format on +#endif + +#define ML99_PRIV_EVAL_0abort(_k, k_cx, folder, acc, _tail, ...) \ + ML99_PRIV_REC_CONTINUE(ML99_PRIV_EVAL_MATCH) \ + (ML99_PRIV_REC_STOP, (~), 0fspace, ML99_PRIV_EVAL_ACC, __VA_ARGS__, (0end, ~), ~) + +#define ML99_PRIV_EVAL_0end(k, k_cx, _folder, acc, _tail, _) \ + ML99_PRIV_REC_CONTINUE(k) \ + (ML99_PRIV_EXPAND k_cx, ML99_PRIV_EVAL_ACC_UNWRAP acc) +// } (Reduction rules) + +// Continuations { + +#define ML99_PRIV_EVAL_0v_K(k, k_cx, folder, acc, tail, ...) \ + ML99_PRIV_MACHINE_REDUCE( \ + k, \ + k_cx, \ + folder, \ + ML99_PRIV_EVAL_##folder(acc, __VA_ARGS__), \ + ML99_PRIV_EXPAND tail) + +#define ML99_PRIV_EVAL_0args_K(k, k_cx, folder, acc, tail, op, ...) \ + ML99_PRIV_MACHINE_REDUCE( \ + ML99_PRIV_EVAL_0callUneval_K, \ + (k, k_cx, folder, acc, tail, op), \ + 0fcomma, \ + ML99_PRIV_EVAL_ACC_COMMA_SEP, \ + __VA_ARGS__, \ + (0end, ~), \ + ~) + +#define ML99_PRIV_EVAL_0op_K(k, k_cx, folder, acc, tail, op, ...) \ + ML99_PRIV_MACHINE_REDUCE( \ + ML99_PRIV_EVAL_0callUneval_K, \ + (k, k_cx, folder, acc, tail), \ + 0fcomma, \ + ML99_PRIV_EVAL_ACC_COMMA_SEP, \ + op, \ + __VA_ARGS__, \ + (0end, ~), \ + ~) + +/* + * In this subroutine, we employ the following optimization: + * + * - If `evaluated_op` expands to many terms, we first evaluate these terms and accumulate them + * (`ML99_PRIV_EVAL_0callUneval_K_1`). + * - Otherwise, we just paste a single term with the rest of the tail + * (`ML99_PRIV_EVAL_0callUneval_K_0`). + */ +#define ML99_PRIV_EVAL_0callUneval_K(k, k_cx, folder, acc, tail, evaluated_op, ...) \ + ML99_PRIV_EVAL_0callUneval_K_AUX(k, k_cx, folder, acc, tail, evaluated_op##_IMPL(__VA_ARGS__)) + +#define ML99_PRIV_EVAL_0callUneval_K_AUX(k, k_cx, folder, acc, tail, ...) \ + ML99_PRIV_CAT(ML99_PRIV_EVAL_0callUneval_K_, ML99_PRIV_CONTAINS_COMMA(__VA_ARGS__)) \ + (k, k_cx, folder, acc, tail, __VA_ARGS__) + +#define ML99_PRIV_EVAL_0callUneval_K_0(k, k_cx, folder, acc, tail, body) \ + ML99_PRIV_MACHINE_REDUCE(k, k_cx, folder, acc, body, ML99_PRIV_EXPAND tail) + +#define ML99_PRIV_EVAL_0callUneval_K_1(k, k_cx, folder, acc, tail, ...) \ + ML99_PRIV_MACHINE_REDUCE( \ + ML99_PRIV_EVAL_0v_K, \ + (k, k_cx, folder, acc, tail), \ + 0fspace, \ + ML99_PRIV_EVAL_ACC, \ + __VA_ARGS__, \ + (0end, ~), \ + ~) + +#define ML99_PRIV_MACHINE_REDUCE(...) ML99_PRIV_EVAL_MATCH(__VA_ARGS__) +// } (Continuations) + +#endif // ML99_EVAL_EVAL_H diff --git a/test/external/metalang99/include/metalang99/eval/rec.h b/test/external/metalang99/include/metalang99/eval/rec.h new file mode 100644 index 0000000..aab238a --- /dev/null +++ b/test/external/metalang99/include/metalang99/eval/rec.h @@ -0,0 +1,1098 @@ +/* + * This recursion engine takes its roots from map-macro [1] and Cloak [2], with a few improvements: + * + * - It can do many more expansions (roughly 1024 * 16 or 2^14). + * + * - The expansion chain is linear: `ML99_PRIV_REC_0` invokes `ML99_PRIV_REC_1`, `ML99_PRIV_REC_1` + * invokes `ML99_PRIV_REC_2`, and so on. + * + * - If a given metaprogram does not require more expansions, then it will stop expanding. I.e., + * perform only as many expansions as needed. This is controlled by `ML99_PRIV_REC_NEXT`: if + * `choice` is `0stop`, then just terminate the expansion chain. + * + * - The last expander `ML99_PRIV_REC_1023` really results in a deferred `ML99_PRIV_REC_0`, not to + * make it painted blue. Then, in `ML99_PRIV_REC_UNROLL_AUX`, this `ML99_PRIV_REC_0` is expanded + * once again 16 times. + * + * - It requires recursive macros to be written in CPS, continuation-passing style [3]. This is + * controlled by `ML99_PRIV_REC_CONTINUE`: the `k` parameter stands for "continuation". `k` must + * eventually expand to yet another `ML99_PRIV_REC_CONTINUE`. Also, there is a special continuation + * called `ML99_PRIV_REC_STOP` -- it terminates the engine. + * + * The minimal usage example is located at `tests/eval/rec.c`. + * + * [1] https://github.com/swansontec/map-macro + * [2] https://github.com/pfultz2/Cloak/wiki/C-Preprocessor-tricks,-tips,-and-idioms#recursion + * [3] https://en.wikipedia.org/wiki/Continuation-passing_style + */ + +#ifndef ML99_EVAL_REC_H +#define ML99_EVAL_REC_H + +#define ML99_PRIV_REC_CONTINUE(k) 0continue, ML99_PRIV_REC_DEFER(k##_HOOK)() +#define ML99_PRIV_REC_STOP(_k_cx, ...) 0stop, __VA_ARGS__ +#define ML99_PRIV_REC_STOP_HOOK() ML99_PRIV_REC_STOP + +#define ML99_PRIV_REC_DEFER(op) op ML99_PRIV_REC_EMPTY +#define ML99_PRIV_REC_EMPTY +#define ML99_PRIV_REC_EXPAND(...) __VA_ARGS__ + +#define ML99_PRIV_REC_NEXT(next_lvl, choice) ML99_PRIV_REC_NEXT_##choice(next_lvl) +#define ML99_PRIV_REC_NEXT_0continue(next_lvl) ML99_PRIV_REC_##next_lvl +#define ML99_PRIV_REC_NEXT_0stop(_next_lvl) ML99_PRIV_REC_HALT + +#define ML99_PRIV_REC_HALT(...) __VA_ARGS__ + +#define ML99_PRIV_REC_UNROLL(...) ML99_PRIV_REC_UNROLL_AUX(__VA_ARGS__) + +// clang-format off +#define ML99_PRIV_REC_UNROLL_AUX(choice, ...) \ + /* Approximately 1024 * 16 reduction steps. */ \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_EXPAND( \ + ML99_PRIV_REC_NEXT(0, choice)(__VA_ARGS__) \ + )))))))))))))))) +// clang-format on + +#define ML99_PRIV_REC_0(choice, ...) ML99_PRIV_REC_NEXT(1, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1(choice, ...) ML99_PRIV_REC_NEXT(2, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_2(choice, ...) ML99_PRIV_REC_NEXT(3, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_3(choice, ...) ML99_PRIV_REC_NEXT(4, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_4(choice, ...) ML99_PRIV_REC_NEXT(5, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_5(choice, ...) ML99_PRIV_REC_NEXT(6, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_6(choice, ...) ML99_PRIV_REC_NEXT(7, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_7(choice, ...) ML99_PRIV_REC_NEXT(8, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_8(choice, ...) ML99_PRIV_REC_NEXT(9, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_9(choice, ...) ML99_PRIV_REC_NEXT(10, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_10(choice, ...) ML99_PRIV_REC_NEXT(11, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_11(choice, ...) ML99_PRIV_REC_NEXT(12, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_12(choice, ...) ML99_PRIV_REC_NEXT(13, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_13(choice, ...) ML99_PRIV_REC_NEXT(14, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_14(choice, ...) ML99_PRIV_REC_NEXT(15, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_15(choice, ...) ML99_PRIV_REC_NEXT(16, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_16(choice, ...) ML99_PRIV_REC_NEXT(17, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_17(choice, ...) ML99_PRIV_REC_NEXT(18, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_18(choice, ...) ML99_PRIV_REC_NEXT(19, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_19(choice, ...) ML99_PRIV_REC_NEXT(20, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_20(choice, ...) ML99_PRIV_REC_NEXT(21, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_21(choice, ...) ML99_PRIV_REC_NEXT(22, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_22(choice, ...) ML99_PRIV_REC_NEXT(23, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_23(choice, ...) ML99_PRIV_REC_NEXT(24, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_24(choice, ...) ML99_PRIV_REC_NEXT(25, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_25(choice, ...) ML99_PRIV_REC_NEXT(26, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_26(choice, ...) ML99_PRIV_REC_NEXT(27, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_27(choice, ...) ML99_PRIV_REC_NEXT(28, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_28(choice, ...) ML99_PRIV_REC_NEXT(29, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_29(choice, ...) ML99_PRIV_REC_NEXT(30, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_30(choice, ...) ML99_PRIV_REC_NEXT(31, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_31(choice, ...) ML99_PRIV_REC_NEXT(32, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_32(choice, ...) ML99_PRIV_REC_NEXT(33, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_33(choice, ...) ML99_PRIV_REC_NEXT(34, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_34(choice, ...) ML99_PRIV_REC_NEXT(35, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_35(choice, ...) ML99_PRIV_REC_NEXT(36, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_36(choice, ...) ML99_PRIV_REC_NEXT(37, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_37(choice, ...) ML99_PRIV_REC_NEXT(38, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_38(choice, ...) ML99_PRIV_REC_NEXT(39, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_39(choice, ...) ML99_PRIV_REC_NEXT(40, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_40(choice, ...) ML99_PRIV_REC_NEXT(41, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_41(choice, ...) ML99_PRIV_REC_NEXT(42, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_42(choice, ...) ML99_PRIV_REC_NEXT(43, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_43(choice, ...) ML99_PRIV_REC_NEXT(44, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_44(choice, ...) ML99_PRIV_REC_NEXT(45, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_45(choice, ...) ML99_PRIV_REC_NEXT(46, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_46(choice, ...) ML99_PRIV_REC_NEXT(47, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_47(choice, ...) ML99_PRIV_REC_NEXT(48, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_48(choice, ...) ML99_PRIV_REC_NEXT(49, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_49(choice, ...) ML99_PRIV_REC_NEXT(50, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_50(choice, ...) ML99_PRIV_REC_NEXT(51, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_51(choice, ...) ML99_PRIV_REC_NEXT(52, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_52(choice, ...) ML99_PRIV_REC_NEXT(53, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_53(choice, ...) ML99_PRIV_REC_NEXT(54, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_54(choice, ...) ML99_PRIV_REC_NEXT(55, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_55(choice, ...) ML99_PRIV_REC_NEXT(56, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_56(choice, ...) ML99_PRIV_REC_NEXT(57, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_57(choice, ...) ML99_PRIV_REC_NEXT(58, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_58(choice, ...) ML99_PRIV_REC_NEXT(59, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_59(choice, ...) ML99_PRIV_REC_NEXT(60, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_60(choice, ...) ML99_PRIV_REC_NEXT(61, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_61(choice, ...) ML99_PRIV_REC_NEXT(62, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_62(choice, ...) ML99_PRIV_REC_NEXT(63, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_63(choice, ...) ML99_PRIV_REC_NEXT(64, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_64(choice, ...) ML99_PRIV_REC_NEXT(65, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_65(choice, ...) ML99_PRIV_REC_NEXT(66, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_66(choice, ...) ML99_PRIV_REC_NEXT(67, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_67(choice, ...) ML99_PRIV_REC_NEXT(68, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_68(choice, ...) ML99_PRIV_REC_NEXT(69, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_69(choice, ...) ML99_PRIV_REC_NEXT(70, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_70(choice, ...) ML99_PRIV_REC_NEXT(71, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_71(choice, ...) ML99_PRIV_REC_NEXT(72, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_72(choice, ...) ML99_PRIV_REC_NEXT(73, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_73(choice, ...) ML99_PRIV_REC_NEXT(74, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_74(choice, ...) ML99_PRIV_REC_NEXT(75, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_75(choice, ...) ML99_PRIV_REC_NEXT(76, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_76(choice, ...) ML99_PRIV_REC_NEXT(77, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_77(choice, ...) ML99_PRIV_REC_NEXT(78, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_78(choice, ...) ML99_PRIV_REC_NEXT(79, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_79(choice, ...) ML99_PRIV_REC_NEXT(80, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_80(choice, ...) ML99_PRIV_REC_NEXT(81, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_81(choice, ...) ML99_PRIV_REC_NEXT(82, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_82(choice, ...) ML99_PRIV_REC_NEXT(83, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_83(choice, ...) ML99_PRIV_REC_NEXT(84, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_84(choice, ...) ML99_PRIV_REC_NEXT(85, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_85(choice, ...) ML99_PRIV_REC_NEXT(86, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_86(choice, ...) ML99_PRIV_REC_NEXT(87, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_87(choice, ...) ML99_PRIV_REC_NEXT(88, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_88(choice, ...) ML99_PRIV_REC_NEXT(89, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_89(choice, ...) ML99_PRIV_REC_NEXT(90, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_90(choice, ...) ML99_PRIV_REC_NEXT(91, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_91(choice, ...) ML99_PRIV_REC_NEXT(92, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_92(choice, ...) ML99_PRIV_REC_NEXT(93, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_93(choice, ...) ML99_PRIV_REC_NEXT(94, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_94(choice, ...) ML99_PRIV_REC_NEXT(95, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_95(choice, ...) ML99_PRIV_REC_NEXT(96, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_96(choice, ...) ML99_PRIV_REC_NEXT(97, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_97(choice, ...) ML99_PRIV_REC_NEXT(98, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_98(choice, ...) ML99_PRIV_REC_NEXT(99, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_99(choice, ...) ML99_PRIV_REC_NEXT(100, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_100(choice, ...) ML99_PRIV_REC_NEXT(101, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_101(choice, ...) ML99_PRIV_REC_NEXT(102, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_102(choice, ...) ML99_PRIV_REC_NEXT(103, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_103(choice, ...) ML99_PRIV_REC_NEXT(104, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_104(choice, ...) ML99_PRIV_REC_NEXT(105, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_105(choice, ...) ML99_PRIV_REC_NEXT(106, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_106(choice, ...) ML99_PRIV_REC_NEXT(107, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_107(choice, ...) ML99_PRIV_REC_NEXT(108, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_108(choice, ...) ML99_PRIV_REC_NEXT(109, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_109(choice, ...) ML99_PRIV_REC_NEXT(110, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_110(choice, ...) ML99_PRIV_REC_NEXT(111, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_111(choice, ...) ML99_PRIV_REC_NEXT(112, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_112(choice, ...) ML99_PRIV_REC_NEXT(113, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_113(choice, ...) ML99_PRIV_REC_NEXT(114, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_114(choice, ...) ML99_PRIV_REC_NEXT(115, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_115(choice, ...) ML99_PRIV_REC_NEXT(116, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_116(choice, ...) ML99_PRIV_REC_NEXT(117, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_117(choice, ...) ML99_PRIV_REC_NEXT(118, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_118(choice, ...) ML99_PRIV_REC_NEXT(119, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_119(choice, ...) ML99_PRIV_REC_NEXT(120, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_120(choice, ...) ML99_PRIV_REC_NEXT(121, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_121(choice, ...) ML99_PRIV_REC_NEXT(122, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_122(choice, ...) ML99_PRIV_REC_NEXT(123, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_123(choice, ...) ML99_PRIV_REC_NEXT(124, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_124(choice, ...) ML99_PRIV_REC_NEXT(125, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_125(choice, ...) ML99_PRIV_REC_NEXT(126, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_126(choice, ...) ML99_PRIV_REC_NEXT(127, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_127(choice, ...) ML99_PRIV_REC_NEXT(128, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_128(choice, ...) ML99_PRIV_REC_NEXT(129, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_129(choice, ...) ML99_PRIV_REC_NEXT(130, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_130(choice, ...) ML99_PRIV_REC_NEXT(131, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_131(choice, ...) ML99_PRIV_REC_NEXT(132, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_132(choice, ...) ML99_PRIV_REC_NEXT(133, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_133(choice, ...) ML99_PRIV_REC_NEXT(134, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_134(choice, ...) ML99_PRIV_REC_NEXT(135, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_135(choice, ...) ML99_PRIV_REC_NEXT(136, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_136(choice, ...) ML99_PRIV_REC_NEXT(137, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_137(choice, ...) ML99_PRIV_REC_NEXT(138, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_138(choice, ...) ML99_PRIV_REC_NEXT(139, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_139(choice, ...) ML99_PRIV_REC_NEXT(140, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_140(choice, ...) ML99_PRIV_REC_NEXT(141, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_141(choice, ...) ML99_PRIV_REC_NEXT(142, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_142(choice, ...) ML99_PRIV_REC_NEXT(143, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_143(choice, ...) ML99_PRIV_REC_NEXT(144, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_144(choice, ...) ML99_PRIV_REC_NEXT(145, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_145(choice, ...) ML99_PRIV_REC_NEXT(146, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_146(choice, ...) ML99_PRIV_REC_NEXT(147, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_147(choice, ...) ML99_PRIV_REC_NEXT(148, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_148(choice, ...) ML99_PRIV_REC_NEXT(149, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_149(choice, ...) ML99_PRIV_REC_NEXT(150, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_150(choice, ...) ML99_PRIV_REC_NEXT(151, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_151(choice, ...) ML99_PRIV_REC_NEXT(152, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_152(choice, ...) ML99_PRIV_REC_NEXT(153, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_153(choice, ...) ML99_PRIV_REC_NEXT(154, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_154(choice, ...) ML99_PRIV_REC_NEXT(155, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_155(choice, ...) ML99_PRIV_REC_NEXT(156, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_156(choice, ...) ML99_PRIV_REC_NEXT(157, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_157(choice, ...) ML99_PRIV_REC_NEXT(158, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_158(choice, ...) ML99_PRIV_REC_NEXT(159, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_159(choice, ...) ML99_PRIV_REC_NEXT(160, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_160(choice, ...) ML99_PRIV_REC_NEXT(161, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_161(choice, ...) ML99_PRIV_REC_NEXT(162, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_162(choice, ...) ML99_PRIV_REC_NEXT(163, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_163(choice, ...) ML99_PRIV_REC_NEXT(164, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_164(choice, ...) ML99_PRIV_REC_NEXT(165, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_165(choice, ...) ML99_PRIV_REC_NEXT(166, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_166(choice, ...) ML99_PRIV_REC_NEXT(167, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_167(choice, ...) ML99_PRIV_REC_NEXT(168, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_168(choice, ...) ML99_PRIV_REC_NEXT(169, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_169(choice, ...) ML99_PRIV_REC_NEXT(170, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_170(choice, ...) ML99_PRIV_REC_NEXT(171, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_171(choice, ...) ML99_PRIV_REC_NEXT(172, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_172(choice, ...) ML99_PRIV_REC_NEXT(173, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_173(choice, ...) ML99_PRIV_REC_NEXT(174, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_174(choice, ...) ML99_PRIV_REC_NEXT(175, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_175(choice, ...) ML99_PRIV_REC_NEXT(176, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_176(choice, ...) ML99_PRIV_REC_NEXT(177, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_177(choice, ...) ML99_PRIV_REC_NEXT(178, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_178(choice, ...) ML99_PRIV_REC_NEXT(179, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_179(choice, ...) ML99_PRIV_REC_NEXT(180, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_180(choice, ...) ML99_PRIV_REC_NEXT(181, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_181(choice, ...) ML99_PRIV_REC_NEXT(182, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_182(choice, ...) ML99_PRIV_REC_NEXT(183, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_183(choice, ...) ML99_PRIV_REC_NEXT(184, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_184(choice, ...) ML99_PRIV_REC_NEXT(185, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_185(choice, ...) ML99_PRIV_REC_NEXT(186, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_186(choice, ...) ML99_PRIV_REC_NEXT(187, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_187(choice, ...) ML99_PRIV_REC_NEXT(188, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_188(choice, ...) ML99_PRIV_REC_NEXT(189, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_189(choice, ...) ML99_PRIV_REC_NEXT(190, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_190(choice, ...) ML99_PRIV_REC_NEXT(191, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_191(choice, ...) ML99_PRIV_REC_NEXT(192, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_192(choice, ...) ML99_PRIV_REC_NEXT(193, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_193(choice, ...) ML99_PRIV_REC_NEXT(194, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_194(choice, ...) ML99_PRIV_REC_NEXT(195, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_195(choice, ...) ML99_PRIV_REC_NEXT(196, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_196(choice, ...) ML99_PRIV_REC_NEXT(197, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_197(choice, ...) ML99_PRIV_REC_NEXT(198, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_198(choice, ...) ML99_PRIV_REC_NEXT(199, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_199(choice, ...) ML99_PRIV_REC_NEXT(200, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_200(choice, ...) ML99_PRIV_REC_NEXT(201, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_201(choice, ...) ML99_PRIV_REC_NEXT(202, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_202(choice, ...) ML99_PRIV_REC_NEXT(203, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_203(choice, ...) ML99_PRIV_REC_NEXT(204, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_204(choice, ...) ML99_PRIV_REC_NEXT(205, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_205(choice, ...) ML99_PRIV_REC_NEXT(206, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_206(choice, ...) ML99_PRIV_REC_NEXT(207, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_207(choice, ...) ML99_PRIV_REC_NEXT(208, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_208(choice, ...) ML99_PRIV_REC_NEXT(209, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_209(choice, ...) ML99_PRIV_REC_NEXT(210, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_210(choice, ...) ML99_PRIV_REC_NEXT(211, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_211(choice, ...) ML99_PRIV_REC_NEXT(212, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_212(choice, ...) ML99_PRIV_REC_NEXT(213, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_213(choice, ...) ML99_PRIV_REC_NEXT(214, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_214(choice, ...) ML99_PRIV_REC_NEXT(215, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_215(choice, ...) ML99_PRIV_REC_NEXT(216, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_216(choice, ...) ML99_PRIV_REC_NEXT(217, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_217(choice, ...) ML99_PRIV_REC_NEXT(218, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_218(choice, ...) ML99_PRIV_REC_NEXT(219, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_219(choice, ...) ML99_PRIV_REC_NEXT(220, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_220(choice, ...) ML99_PRIV_REC_NEXT(221, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_221(choice, ...) ML99_PRIV_REC_NEXT(222, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_222(choice, ...) ML99_PRIV_REC_NEXT(223, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_223(choice, ...) ML99_PRIV_REC_NEXT(224, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_224(choice, ...) ML99_PRIV_REC_NEXT(225, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_225(choice, ...) ML99_PRIV_REC_NEXT(226, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_226(choice, ...) ML99_PRIV_REC_NEXT(227, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_227(choice, ...) ML99_PRIV_REC_NEXT(228, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_228(choice, ...) ML99_PRIV_REC_NEXT(229, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_229(choice, ...) ML99_PRIV_REC_NEXT(230, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_230(choice, ...) ML99_PRIV_REC_NEXT(231, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_231(choice, ...) ML99_PRIV_REC_NEXT(232, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_232(choice, ...) ML99_PRIV_REC_NEXT(233, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_233(choice, ...) ML99_PRIV_REC_NEXT(234, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_234(choice, ...) ML99_PRIV_REC_NEXT(235, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_235(choice, ...) ML99_PRIV_REC_NEXT(236, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_236(choice, ...) ML99_PRIV_REC_NEXT(237, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_237(choice, ...) ML99_PRIV_REC_NEXT(238, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_238(choice, ...) ML99_PRIV_REC_NEXT(239, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_239(choice, ...) ML99_PRIV_REC_NEXT(240, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_240(choice, ...) ML99_PRIV_REC_NEXT(241, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_241(choice, ...) ML99_PRIV_REC_NEXT(242, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_242(choice, ...) ML99_PRIV_REC_NEXT(243, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_243(choice, ...) ML99_PRIV_REC_NEXT(244, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_244(choice, ...) ML99_PRIV_REC_NEXT(245, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_245(choice, ...) ML99_PRIV_REC_NEXT(246, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_246(choice, ...) ML99_PRIV_REC_NEXT(247, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_247(choice, ...) ML99_PRIV_REC_NEXT(248, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_248(choice, ...) ML99_PRIV_REC_NEXT(249, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_249(choice, ...) ML99_PRIV_REC_NEXT(250, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_250(choice, ...) ML99_PRIV_REC_NEXT(251, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_251(choice, ...) ML99_PRIV_REC_NEXT(252, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_252(choice, ...) ML99_PRIV_REC_NEXT(253, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_253(choice, ...) ML99_PRIV_REC_NEXT(254, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_254(choice, ...) ML99_PRIV_REC_NEXT(255, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_255(choice, ...) ML99_PRIV_REC_NEXT(256, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_256(choice, ...) ML99_PRIV_REC_NEXT(257, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_257(choice, ...) ML99_PRIV_REC_NEXT(258, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_258(choice, ...) ML99_PRIV_REC_NEXT(259, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_259(choice, ...) ML99_PRIV_REC_NEXT(260, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_260(choice, ...) ML99_PRIV_REC_NEXT(261, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_261(choice, ...) ML99_PRIV_REC_NEXT(262, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_262(choice, ...) ML99_PRIV_REC_NEXT(263, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_263(choice, ...) ML99_PRIV_REC_NEXT(264, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_264(choice, ...) ML99_PRIV_REC_NEXT(265, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_265(choice, ...) ML99_PRIV_REC_NEXT(266, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_266(choice, ...) ML99_PRIV_REC_NEXT(267, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_267(choice, ...) ML99_PRIV_REC_NEXT(268, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_268(choice, ...) ML99_PRIV_REC_NEXT(269, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_269(choice, ...) ML99_PRIV_REC_NEXT(270, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_270(choice, ...) ML99_PRIV_REC_NEXT(271, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_271(choice, ...) ML99_PRIV_REC_NEXT(272, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_272(choice, ...) ML99_PRIV_REC_NEXT(273, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_273(choice, ...) ML99_PRIV_REC_NEXT(274, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_274(choice, ...) ML99_PRIV_REC_NEXT(275, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_275(choice, ...) ML99_PRIV_REC_NEXT(276, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_276(choice, ...) ML99_PRIV_REC_NEXT(277, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_277(choice, ...) ML99_PRIV_REC_NEXT(278, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_278(choice, ...) ML99_PRIV_REC_NEXT(279, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_279(choice, ...) ML99_PRIV_REC_NEXT(280, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_280(choice, ...) ML99_PRIV_REC_NEXT(281, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_281(choice, ...) ML99_PRIV_REC_NEXT(282, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_282(choice, ...) ML99_PRIV_REC_NEXT(283, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_283(choice, ...) ML99_PRIV_REC_NEXT(284, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_284(choice, ...) ML99_PRIV_REC_NEXT(285, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_285(choice, ...) ML99_PRIV_REC_NEXT(286, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_286(choice, ...) ML99_PRIV_REC_NEXT(287, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_287(choice, ...) ML99_PRIV_REC_NEXT(288, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_288(choice, ...) ML99_PRIV_REC_NEXT(289, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_289(choice, ...) ML99_PRIV_REC_NEXT(290, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_290(choice, ...) ML99_PRIV_REC_NEXT(291, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_291(choice, ...) ML99_PRIV_REC_NEXT(292, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_292(choice, ...) ML99_PRIV_REC_NEXT(293, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_293(choice, ...) ML99_PRIV_REC_NEXT(294, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_294(choice, ...) ML99_PRIV_REC_NEXT(295, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_295(choice, ...) ML99_PRIV_REC_NEXT(296, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_296(choice, ...) ML99_PRIV_REC_NEXT(297, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_297(choice, ...) ML99_PRIV_REC_NEXT(298, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_298(choice, ...) ML99_PRIV_REC_NEXT(299, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_299(choice, ...) ML99_PRIV_REC_NEXT(300, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_300(choice, ...) ML99_PRIV_REC_NEXT(301, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_301(choice, ...) ML99_PRIV_REC_NEXT(302, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_302(choice, ...) ML99_PRIV_REC_NEXT(303, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_303(choice, ...) ML99_PRIV_REC_NEXT(304, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_304(choice, ...) ML99_PRIV_REC_NEXT(305, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_305(choice, ...) ML99_PRIV_REC_NEXT(306, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_306(choice, ...) ML99_PRIV_REC_NEXT(307, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_307(choice, ...) ML99_PRIV_REC_NEXT(308, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_308(choice, ...) ML99_PRIV_REC_NEXT(309, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_309(choice, ...) ML99_PRIV_REC_NEXT(310, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_310(choice, ...) ML99_PRIV_REC_NEXT(311, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_311(choice, ...) ML99_PRIV_REC_NEXT(312, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_312(choice, ...) ML99_PRIV_REC_NEXT(313, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_313(choice, ...) ML99_PRIV_REC_NEXT(314, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_314(choice, ...) ML99_PRIV_REC_NEXT(315, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_315(choice, ...) ML99_PRIV_REC_NEXT(316, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_316(choice, ...) ML99_PRIV_REC_NEXT(317, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_317(choice, ...) ML99_PRIV_REC_NEXT(318, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_318(choice, ...) ML99_PRIV_REC_NEXT(319, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_319(choice, ...) ML99_PRIV_REC_NEXT(320, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_320(choice, ...) ML99_PRIV_REC_NEXT(321, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_321(choice, ...) ML99_PRIV_REC_NEXT(322, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_322(choice, ...) ML99_PRIV_REC_NEXT(323, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_323(choice, ...) ML99_PRIV_REC_NEXT(324, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_324(choice, ...) ML99_PRIV_REC_NEXT(325, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_325(choice, ...) ML99_PRIV_REC_NEXT(326, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_326(choice, ...) ML99_PRIV_REC_NEXT(327, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_327(choice, ...) ML99_PRIV_REC_NEXT(328, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_328(choice, ...) ML99_PRIV_REC_NEXT(329, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_329(choice, ...) ML99_PRIV_REC_NEXT(330, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_330(choice, ...) ML99_PRIV_REC_NEXT(331, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_331(choice, ...) ML99_PRIV_REC_NEXT(332, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_332(choice, ...) ML99_PRIV_REC_NEXT(333, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_333(choice, ...) ML99_PRIV_REC_NEXT(334, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_334(choice, ...) ML99_PRIV_REC_NEXT(335, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_335(choice, ...) ML99_PRIV_REC_NEXT(336, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_336(choice, ...) ML99_PRIV_REC_NEXT(337, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_337(choice, ...) ML99_PRIV_REC_NEXT(338, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_338(choice, ...) ML99_PRIV_REC_NEXT(339, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_339(choice, ...) ML99_PRIV_REC_NEXT(340, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_340(choice, ...) ML99_PRIV_REC_NEXT(341, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_341(choice, ...) ML99_PRIV_REC_NEXT(342, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_342(choice, ...) ML99_PRIV_REC_NEXT(343, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_343(choice, ...) ML99_PRIV_REC_NEXT(344, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_344(choice, ...) ML99_PRIV_REC_NEXT(345, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_345(choice, ...) ML99_PRIV_REC_NEXT(346, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_346(choice, ...) ML99_PRIV_REC_NEXT(347, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_347(choice, ...) ML99_PRIV_REC_NEXT(348, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_348(choice, ...) ML99_PRIV_REC_NEXT(349, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_349(choice, ...) ML99_PRIV_REC_NEXT(350, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_350(choice, ...) ML99_PRIV_REC_NEXT(351, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_351(choice, ...) ML99_PRIV_REC_NEXT(352, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_352(choice, ...) ML99_PRIV_REC_NEXT(353, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_353(choice, ...) ML99_PRIV_REC_NEXT(354, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_354(choice, ...) ML99_PRIV_REC_NEXT(355, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_355(choice, ...) ML99_PRIV_REC_NEXT(356, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_356(choice, ...) ML99_PRIV_REC_NEXT(357, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_357(choice, ...) ML99_PRIV_REC_NEXT(358, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_358(choice, ...) ML99_PRIV_REC_NEXT(359, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_359(choice, ...) ML99_PRIV_REC_NEXT(360, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_360(choice, ...) ML99_PRIV_REC_NEXT(361, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_361(choice, ...) ML99_PRIV_REC_NEXT(362, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_362(choice, ...) ML99_PRIV_REC_NEXT(363, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_363(choice, ...) ML99_PRIV_REC_NEXT(364, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_364(choice, ...) ML99_PRIV_REC_NEXT(365, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_365(choice, ...) ML99_PRIV_REC_NEXT(366, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_366(choice, ...) ML99_PRIV_REC_NEXT(367, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_367(choice, ...) ML99_PRIV_REC_NEXT(368, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_368(choice, ...) ML99_PRIV_REC_NEXT(369, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_369(choice, ...) ML99_PRIV_REC_NEXT(370, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_370(choice, ...) ML99_PRIV_REC_NEXT(371, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_371(choice, ...) ML99_PRIV_REC_NEXT(372, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_372(choice, ...) ML99_PRIV_REC_NEXT(373, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_373(choice, ...) ML99_PRIV_REC_NEXT(374, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_374(choice, ...) ML99_PRIV_REC_NEXT(375, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_375(choice, ...) ML99_PRIV_REC_NEXT(376, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_376(choice, ...) ML99_PRIV_REC_NEXT(377, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_377(choice, ...) ML99_PRIV_REC_NEXT(378, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_378(choice, ...) ML99_PRIV_REC_NEXT(379, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_379(choice, ...) ML99_PRIV_REC_NEXT(380, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_380(choice, ...) ML99_PRIV_REC_NEXT(381, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_381(choice, ...) ML99_PRIV_REC_NEXT(382, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_382(choice, ...) ML99_PRIV_REC_NEXT(383, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_383(choice, ...) ML99_PRIV_REC_NEXT(384, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_384(choice, ...) ML99_PRIV_REC_NEXT(385, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_385(choice, ...) ML99_PRIV_REC_NEXT(386, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_386(choice, ...) ML99_PRIV_REC_NEXT(387, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_387(choice, ...) ML99_PRIV_REC_NEXT(388, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_388(choice, ...) ML99_PRIV_REC_NEXT(389, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_389(choice, ...) ML99_PRIV_REC_NEXT(390, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_390(choice, ...) ML99_PRIV_REC_NEXT(391, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_391(choice, ...) ML99_PRIV_REC_NEXT(392, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_392(choice, ...) ML99_PRIV_REC_NEXT(393, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_393(choice, ...) ML99_PRIV_REC_NEXT(394, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_394(choice, ...) ML99_PRIV_REC_NEXT(395, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_395(choice, ...) ML99_PRIV_REC_NEXT(396, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_396(choice, ...) ML99_PRIV_REC_NEXT(397, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_397(choice, ...) ML99_PRIV_REC_NEXT(398, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_398(choice, ...) ML99_PRIV_REC_NEXT(399, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_399(choice, ...) ML99_PRIV_REC_NEXT(400, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_400(choice, ...) ML99_PRIV_REC_NEXT(401, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_401(choice, ...) ML99_PRIV_REC_NEXT(402, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_402(choice, ...) ML99_PRIV_REC_NEXT(403, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_403(choice, ...) ML99_PRIV_REC_NEXT(404, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_404(choice, ...) ML99_PRIV_REC_NEXT(405, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_405(choice, ...) ML99_PRIV_REC_NEXT(406, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_406(choice, ...) ML99_PRIV_REC_NEXT(407, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_407(choice, ...) ML99_PRIV_REC_NEXT(408, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_408(choice, ...) ML99_PRIV_REC_NEXT(409, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_409(choice, ...) ML99_PRIV_REC_NEXT(410, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_410(choice, ...) ML99_PRIV_REC_NEXT(411, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_411(choice, ...) ML99_PRIV_REC_NEXT(412, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_412(choice, ...) ML99_PRIV_REC_NEXT(413, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_413(choice, ...) ML99_PRIV_REC_NEXT(414, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_414(choice, ...) ML99_PRIV_REC_NEXT(415, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_415(choice, ...) ML99_PRIV_REC_NEXT(416, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_416(choice, ...) ML99_PRIV_REC_NEXT(417, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_417(choice, ...) ML99_PRIV_REC_NEXT(418, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_418(choice, ...) ML99_PRIV_REC_NEXT(419, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_419(choice, ...) ML99_PRIV_REC_NEXT(420, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_420(choice, ...) ML99_PRIV_REC_NEXT(421, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_421(choice, ...) ML99_PRIV_REC_NEXT(422, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_422(choice, ...) ML99_PRIV_REC_NEXT(423, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_423(choice, ...) ML99_PRIV_REC_NEXT(424, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_424(choice, ...) ML99_PRIV_REC_NEXT(425, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_425(choice, ...) ML99_PRIV_REC_NEXT(426, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_426(choice, ...) ML99_PRIV_REC_NEXT(427, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_427(choice, ...) ML99_PRIV_REC_NEXT(428, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_428(choice, ...) ML99_PRIV_REC_NEXT(429, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_429(choice, ...) ML99_PRIV_REC_NEXT(430, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_430(choice, ...) ML99_PRIV_REC_NEXT(431, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_431(choice, ...) ML99_PRIV_REC_NEXT(432, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_432(choice, ...) ML99_PRIV_REC_NEXT(433, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_433(choice, ...) ML99_PRIV_REC_NEXT(434, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_434(choice, ...) ML99_PRIV_REC_NEXT(435, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_435(choice, ...) ML99_PRIV_REC_NEXT(436, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_436(choice, ...) ML99_PRIV_REC_NEXT(437, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_437(choice, ...) ML99_PRIV_REC_NEXT(438, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_438(choice, ...) ML99_PRIV_REC_NEXT(439, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_439(choice, ...) ML99_PRIV_REC_NEXT(440, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_440(choice, ...) ML99_PRIV_REC_NEXT(441, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_441(choice, ...) ML99_PRIV_REC_NEXT(442, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_442(choice, ...) ML99_PRIV_REC_NEXT(443, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_443(choice, ...) ML99_PRIV_REC_NEXT(444, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_444(choice, ...) ML99_PRIV_REC_NEXT(445, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_445(choice, ...) ML99_PRIV_REC_NEXT(446, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_446(choice, ...) ML99_PRIV_REC_NEXT(447, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_447(choice, ...) ML99_PRIV_REC_NEXT(448, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_448(choice, ...) ML99_PRIV_REC_NEXT(449, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_449(choice, ...) ML99_PRIV_REC_NEXT(450, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_450(choice, ...) ML99_PRIV_REC_NEXT(451, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_451(choice, ...) ML99_PRIV_REC_NEXT(452, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_452(choice, ...) ML99_PRIV_REC_NEXT(453, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_453(choice, ...) ML99_PRIV_REC_NEXT(454, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_454(choice, ...) ML99_PRIV_REC_NEXT(455, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_455(choice, ...) ML99_PRIV_REC_NEXT(456, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_456(choice, ...) ML99_PRIV_REC_NEXT(457, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_457(choice, ...) ML99_PRIV_REC_NEXT(458, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_458(choice, ...) ML99_PRIV_REC_NEXT(459, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_459(choice, ...) ML99_PRIV_REC_NEXT(460, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_460(choice, ...) ML99_PRIV_REC_NEXT(461, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_461(choice, ...) ML99_PRIV_REC_NEXT(462, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_462(choice, ...) ML99_PRIV_REC_NEXT(463, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_463(choice, ...) ML99_PRIV_REC_NEXT(464, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_464(choice, ...) ML99_PRIV_REC_NEXT(465, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_465(choice, ...) ML99_PRIV_REC_NEXT(466, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_466(choice, ...) ML99_PRIV_REC_NEXT(467, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_467(choice, ...) ML99_PRIV_REC_NEXT(468, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_468(choice, ...) ML99_PRIV_REC_NEXT(469, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_469(choice, ...) ML99_PRIV_REC_NEXT(470, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_470(choice, ...) ML99_PRIV_REC_NEXT(471, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_471(choice, ...) ML99_PRIV_REC_NEXT(472, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_472(choice, ...) ML99_PRIV_REC_NEXT(473, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_473(choice, ...) ML99_PRIV_REC_NEXT(474, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_474(choice, ...) ML99_PRIV_REC_NEXT(475, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_475(choice, ...) ML99_PRIV_REC_NEXT(476, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_476(choice, ...) ML99_PRIV_REC_NEXT(477, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_477(choice, ...) ML99_PRIV_REC_NEXT(478, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_478(choice, ...) ML99_PRIV_REC_NEXT(479, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_479(choice, ...) ML99_PRIV_REC_NEXT(480, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_480(choice, ...) ML99_PRIV_REC_NEXT(481, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_481(choice, ...) ML99_PRIV_REC_NEXT(482, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_482(choice, ...) ML99_PRIV_REC_NEXT(483, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_483(choice, ...) ML99_PRIV_REC_NEXT(484, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_484(choice, ...) ML99_PRIV_REC_NEXT(485, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_485(choice, ...) ML99_PRIV_REC_NEXT(486, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_486(choice, ...) ML99_PRIV_REC_NEXT(487, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_487(choice, ...) ML99_PRIV_REC_NEXT(488, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_488(choice, ...) ML99_PRIV_REC_NEXT(489, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_489(choice, ...) ML99_PRIV_REC_NEXT(490, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_490(choice, ...) ML99_PRIV_REC_NEXT(491, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_491(choice, ...) ML99_PRIV_REC_NEXT(492, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_492(choice, ...) ML99_PRIV_REC_NEXT(493, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_493(choice, ...) ML99_PRIV_REC_NEXT(494, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_494(choice, ...) ML99_PRIV_REC_NEXT(495, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_495(choice, ...) ML99_PRIV_REC_NEXT(496, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_496(choice, ...) ML99_PRIV_REC_NEXT(497, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_497(choice, ...) ML99_PRIV_REC_NEXT(498, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_498(choice, ...) ML99_PRIV_REC_NEXT(499, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_499(choice, ...) ML99_PRIV_REC_NEXT(500, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_500(choice, ...) ML99_PRIV_REC_NEXT(501, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_501(choice, ...) ML99_PRIV_REC_NEXT(502, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_502(choice, ...) ML99_PRIV_REC_NEXT(503, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_503(choice, ...) ML99_PRIV_REC_NEXT(504, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_504(choice, ...) ML99_PRIV_REC_NEXT(505, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_505(choice, ...) ML99_PRIV_REC_NEXT(506, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_506(choice, ...) ML99_PRIV_REC_NEXT(507, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_507(choice, ...) ML99_PRIV_REC_NEXT(508, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_508(choice, ...) ML99_PRIV_REC_NEXT(509, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_509(choice, ...) ML99_PRIV_REC_NEXT(510, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_510(choice, ...) ML99_PRIV_REC_NEXT(511, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_511(choice, ...) ML99_PRIV_REC_NEXT(512, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_512(choice, ...) ML99_PRIV_REC_NEXT(513, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_513(choice, ...) ML99_PRIV_REC_NEXT(514, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_514(choice, ...) ML99_PRIV_REC_NEXT(515, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_515(choice, ...) ML99_PRIV_REC_NEXT(516, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_516(choice, ...) ML99_PRIV_REC_NEXT(517, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_517(choice, ...) ML99_PRIV_REC_NEXT(518, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_518(choice, ...) ML99_PRIV_REC_NEXT(519, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_519(choice, ...) ML99_PRIV_REC_NEXT(520, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_520(choice, ...) ML99_PRIV_REC_NEXT(521, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_521(choice, ...) ML99_PRIV_REC_NEXT(522, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_522(choice, ...) ML99_PRIV_REC_NEXT(523, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_523(choice, ...) ML99_PRIV_REC_NEXT(524, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_524(choice, ...) ML99_PRIV_REC_NEXT(525, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_525(choice, ...) ML99_PRIV_REC_NEXT(526, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_526(choice, ...) ML99_PRIV_REC_NEXT(527, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_527(choice, ...) ML99_PRIV_REC_NEXT(528, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_528(choice, ...) ML99_PRIV_REC_NEXT(529, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_529(choice, ...) ML99_PRIV_REC_NEXT(530, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_530(choice, ...) ML99_PRIV_REC_NEXT(531, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_531(choice, ...) ML99_PRIV_REC_NEXT(532, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_532(choice, ...) ML99_PRIV_REC_NEXT(533, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_533(choice, ...) ML99_PRIV_REC_NEXT(534, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_534(choice, ...) ML99_PRIV_REC_NEXT(535, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_535(choice, ...) ML99_PRIV_REC_NEXT(536, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_536(choice, ...) ML99_PRIV_REC_NEXT(537, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_537(choice, ...) ML99_PRIV_REC_NEXT(538, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_538(choice, ...) ML99_PRIV_REC_NEXT(539, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_539(choice, ...) ML99_PRIV_REC_NEXT(540, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_540(choice, ...) ML99_PRIV_REC_NEXT(541, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_541(choice, ...) ML99_PRIV_REC_NEXT(542, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_542(choice, ...) ML99_PRIV_REC_NEXT(543, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_543(choice, ...) ML99_PRIV_REC_NEXT(544, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_544(choice, ...) ML99_PRIV_REC_NEXT(545, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_545(choice, ...) ML99_PRIV_REC_NEXT(546, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_546(choice, ...) ML99_PRIV_REC_NEXT(547, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_547(choice, ...) ML99_PRIV_REC_NEXT(548, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_548(choice, ...) ML99_PRIV_REC_NEXT(549, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_549(choice, ...) ML99_PRIV_REC_NEXT(550, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_550(choice, ...) ML99_PRIV_REC_NEXT(551, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_551(choice, ...) ML99_PRIV_REC_NEXT(552, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_552(choice, ...) ML99_PRIV_REC_NEXT(553, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_553(choice, ...) ML99_PRIV_REC_NEXT(554, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_554(choice, ...) ML99_PRIV_REC_NEXT(555, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_555(choice, ...) ML99_PRIV_REC_NEXT(556, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_556(choice, ...) ML99_PRIV_REC_NEXT(557, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_557(choice, ...) ML99_PRIV_REC_NEXT(558, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_558(choice, ...) ML99_PRIV_REC_NEXT(559, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_559(choice, ...) ML99_PRIV_REC_NEXT(560, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_560(choice, ...) ML99_PRIV_REC_NEXT(561, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_561(choice, ...) ML99_PRIV_REC_NEXT(562, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_562(choice, ...) ML99_PRIV_REC_NEXT(563, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_563(choice, ...) ML99_PRIV_REC_NEXT(564, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_564(choice, ...) ML99_PRIV_REC_NEXT(565, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_565(choice, ...) ML99_PRIV_REC_NEXT(566, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_566(choice, ...) ML99_PRIV_REC_NEXT(567, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_567(choice, ...) ML99_PRIV_REC_NEXT(568, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_568(choice, ...) ML99_PRIV_REC_NEXT(569, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_569(choice, ...) ML99_PRIV_REC_NEXT(570, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_570(choice, ...) ML99_PRIV_REC_NEXT(571, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_571(choice, ...) ML99_PRIV_REC_NEXT(572, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_572(choice, ...) ML99_PRIV_REC_NEXT(573, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_573(choice, ...) ML99_PRIV_REC_NEXT(574, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_574(choice, ...) ML99_PRIV_REC_NEXT(575, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_575(choice, ...) ML99_PRIV_REC_NEXT(576, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_576(choice, ...) ML99_PRIV_REC_NEXT(577, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_577(choice, ...) ML99_PRIV_REC_NEXT(578, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_578(choice, ...) ML99_PRIV_REC_NEXT(579, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_579(choice, ...) ML99_PRIV_REC_NEXT(580, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_580(choice, ...) ML99_PRIV_REC_NEXT(581, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_581(choice, ...) ML99_PRIV_REC_NEXT(582, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_582(choice, ...) ML99_PRIV_REC_NEXT(583, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_583(choice, ...) ML99_PRIV_REC_NEXT(584, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_584(choice, ...) ML99_PRIV_REC_NEXT(585, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_585(choice, ...) ML99_PRIV_REC_NEXT(586, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_586(choice, ...) ML99_PRIV_REC_NEXT(587, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_587(choice, ...) ML99_PRIV_REC_NEXT(588, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_588(choice, ...) ML99_PRIV_REC_NEXT(589, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_589(choice, ...) ML99_PRIV_REC_NEXT(590, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_590(choice, ...) ML99_PRIV_REC_NEXT(591, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_591(choice, ...) ML99_PRIV_REC_NEXT(592, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_592(choice, ...) ML99_PRIV_REC_NEXT(593, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_593(choice, ...) ML99_PRIV_REC_NEXT(594, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_594(choice, ...) ML99_PRIV_REC_NEXT(595, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_595(choice, ...) ML99_PRIV_REC_NEXT(596, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_596(choice, ...) ML99_PRIV_REC_NEXT(597, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_597(choice, ...) ML99_PRIV_REC_NEXT(598, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_598(choice, ...) ML99_PRIV_REC_NEXT(599, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_599(choice, ...) ML99_PRIV_REC_NEXT(600, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_600(choice, ...) ML99_PRIV_REC_NEXT(601, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_601(choice, ...) ML99_PRIV_REC_NEXT(602, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_602(choice, ...) ML99_PRIV_REC_NEXT(603, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_603(choice, ...) ML99_PRIV_REC_NEXT(604, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_604(choice, ...) ML99_PRIV_REC_NEXT(605, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_605(choice, ...) ML99_PRIV_REC_NEXT(606, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_606(choice, ...) ML99_PRIV_REC_NEXT(607, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_607(choice, ...) ML99_PRIV_REC_NEXT(608, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_608(choice, ...) ML99_PRIV_REC_NEXT(609, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_609(choice, ...) ML99_PRIV_REC_NEXT(610, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_610(choice, ...) ML99_PRIV_REC_NEXT(611, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_611(choice, ...) ML99_PRIV_REC_NEXT(612, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_612(choice, ...) ML99_PRIV_REC_NEXT(613, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_613(choice, ...) ML99_PRIV_REC_NEXT(614, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_614(choice, ...) ML99_PRIV_REC_NEXT(615, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_615(choice, ...) ML99_PRIV_REC_NEXT(616, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_616(choice, ...) ML99_PRIV_REC_NEXT(617, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_617(choice, ...) ML99_PRIV_REC_NEXT(618, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_618(choice, ...) ML99_PRIV_REC_NEXT(619, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_619(choice, ...) ML99_PRIV_REC_NEXT(620, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_620(choice, ...) ML99_PRIV_REC_NEXT(621, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_621(choice, ...) ML99_PRIV_REC_NEXT(622, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_622(choice, ...) ML99_PRIV_REC_NEXT(623, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_623(choice, ...) ML99_PRIV_REC_NEXT(624, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_624(choice, ...) ML99_PRIV_REC_NEXT(625, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_625(choice, ...) ML99_PRIV_REC_NEXT(626, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_626(choice, ...) ML99_PRIV_REC_NEXT(627, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_627(choice, ...) ML99_PRIV_REC_NEXT(628, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_628(choice, ...) ML99_PRIV_REC_NEXT(629, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_629(choice, ...) ML99_PRIV_REC_NEXT(630, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_630(choice, ...) ML99_PRIV_REC_NEXT(631, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_631(choice, ...) ML99_PRIV_REC_NEXT(632, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_632(choice, ...) ML99_PRIV_REC_NEXT(633, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_633(choice, ...) ML99_PRIV_REC_NEXT(634, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_634(choice, ...) ML99_PRIV_REC_NEXT(635, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_635(choice, ...) ML99_PRIV_REC_NEXT(636, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_636(choice, ...) ML99_PRIV_REC_NEXT(637, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_637(choice, ...) ML99_PRIV_REC_NEXT(638, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_638(choice, ...) ML99_PRIV_REC_NEXT(639, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_639(choice, ...) ML99_PRIV_REC_NEXT(640, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_640(choice, ...) ML99_PRIV_REC_NEXT(641, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_641(choice, ...) ML99_PRIV_REC_NEXT(642, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_642(choice, ...) ML99_PRIV_REC_NEXT(643, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_643(choice, ...) ML99_PRIV_REC_NEXT(644, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_644(choice, ...) ML99_PRIV_REC_NEXT(645, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_645(choice, ...) ML99_PRIV_REC_NEXT(646, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_646(choice, ...) ML99_PRIV_REC_NEXT(647, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_647(choice, ...) ML99_PRIV_REC_NEXT(648, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_648(choice, ...) ML99_PRIV_REC_NEXT(649, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_649(choice, ...) ML99_PRIV_REC_NEXT(650, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_650(choice, ...) ML99_PRIV_REC_NEXT(651, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_651(choice, ...) ML99_PRIV_REC_NEXT(652, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_652(choice, ...) ML99_PRIV_REC_NEXT(653, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_653(choice, ...) ML99_PRIV_REC_NEXT(654, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_654(choice, ...) ML99_PRIV_REC_NEXT(655, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_655(choice, ...) ML99_PRIV_REC_NEXT(656, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_656(choice, ...) ML99_PRIV_REC_NEXT(657, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_657(choice, ...) ML99_PRIV_REC_NEXT(658, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_658(choice, ...) ML99_PRIV_REC_NEXT(659, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_659(choice, ...) ML99_PRIV_REC_NEXT(660, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_660(choice, ...) ML99_PRIV_REC_NEXT(661, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_661(choice, ...) ML99_PRIV_REC_NEXT(662, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_662(choice, ...) ML99_PRIV_REC_NEXT(663, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_663(choice, ...) ML99_PRIV_REC_NEXT(664, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_664(choice, ...) ML99_PRIV_REC_NEXT(665, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_665(choice, ...) ML99_PRIV_REC_NEXT(666, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_666(choice, ...) ML99_PRIV_REC_NEXT(667, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_667(choice, ...) ML99_PRIV_REC_NEXT(668, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_668(choice, ...) ML99_PRIV_REC_NEXT(669, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_669(choice, ...) ML99_PRIV_REC_NEXT(670, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_670(choice, ...) ML99_PRIV_REC_NEXT(671, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_671(choice, ...) ML99_PRIV_REC_NEXT(672, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_672(choice, ...) ML99_PRIV_REC_NEXT(673, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_673(choice, ...) ML99_PRIV_REC_NEXT(674, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_674(choice, ...) ML99_PRIV_REC_NEXT(675, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_675(choice, ...) ML99_PRIV_REC_NEXT(676, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_676(choice, ...) ML99_PRIV_REC_NEXT(677, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_677(choice, ...) ML99_PRIV_REC_NEXT(678, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_678(choice, ...) ML99_PRIV_REC_NEXT(679, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_679(choice, ...) ML99_PRIV_REC_NEXT(680, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_680(choice, ...) ML99_PRIV_REC_NEXT(681, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_681(choice, ...) ML99_PRIV_REC_NEXT(682, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_682(choice, ...) ML99_PRIV_REC_NEXT(683, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_683(choice, ...) ML99_PRIV_REC_NEXT(684, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_684(choice, ...) ML99_PRIV_REC_NEXT(685, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_685(choice, ...) ML99_PRIV_REC_NEXT(686, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_686(choice, ...) ML99_PRIV_REC_NEXT(687, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_687(choice, ...) ML99_PRIV_REC_NEXT(688, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_688(choice, ...) ML99_PRIV_REC_NEXT(689, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_689(choice, ...) ML99_PRIV_REC_NEXT(690, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_690(choice, ...) ML99_PRIV_REC_NEXT(691, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_691(choice, ...) ML99_PRIV_REC_NEXT(692, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_692(choice, ...) ML99_PRIV_REC_NEXT(693, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_693(choice, ...) ML99_PRIV_REC_NEXT(694, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_694(choice, ...) ML99_PRIV_REC_NEXT(695, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_695(choice, ...) ML99_PRIV_REC_NEXT(696, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_696(choice, ...) ML99_PRIV_REC_NEXT(697, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_697(choice, ...) ML99_PRIV_REC_NEXT(698, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_698(choice, ...) ML99_PRIV_REC_NEXT(699, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_699(choice, ...) ML99_PRIV_REC_NEXT(700, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_700(choice, ...) ML99_PRIV_REC_NEXT(701, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_701(choice, ...) ML99_PRIV_REC_NEXT(702, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_702(choice, ...) ML99_PRIV_REC_NEXT(703, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_703(choice, ...) ML99_PRIV_REC_NEXT(704, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_704(choice, ...) ML99_PRIV_REC_NEXT(705, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_705(choice, ...) ML99_PRIV_REC_NEXT(706, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_706(choice, ...) ML99_PRIV_REC_NEXT(707, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_707(choice, ...) ML99_PRIV_REC_NEXT(708, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_708(choice, ...) ML99_PRIV_REC_NEXT(709, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_709(choice, ...) ML99_PRIV_REC_NEXT(710, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_710(choice, ...) ML99_PRIV_REC_NEXT(711, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_711(choice, ...) ML99_PRIV_REC_NEXT(712, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_712(choice, ...) ML99_PRIV_REC_NEXT(713, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_713(choice, ...) ML99_PRIV_REC_NEXT(714, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_714(choice, ...) ML99_PRIV_REC_NEXT(715, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_715(choice, ...) ML99_PRIV_REC_NEXT(716, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_716(choice, ...) ML99_PRIV_REC_NEXT(717, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_717(choice, ...) ML99_PRIV_REC_NEXT(718, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_718(choice, ...) ML99_PRIV_REC_NEXT(719, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_719(choice, ...) ML99_PRIV_REC_NEXT(720, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_720(choice, ...) ML99_PRIV_REC_NEXT(721, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_721(choice, ...) ML99_PRIV_REC_NEXT(722, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_722(choice, ...) ML99_PRIV_REC_NEXT(723, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_723(choice, ...) ML99_PRIV_REC_NEXT(724, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_724(choice, ...) ML99_PRIV_REC_NEXT(725, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_725(choice, ...) ML99_PRIV_REC_NEXT(726, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_726(choice, ...) ML99_PRIV_REC_NEXT(727, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_727(choice, ...) ML99_PRIV_REC_NEXT(728, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_728(choice, ...) ML99_PRIV_REC_NEXT(729, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_729(choice, ...) ML99_PRIV_REC_NEXT(730, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_730(choice, ...) ML99_PRIV_REC_NEXT(731, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_731(choice, ...) ML99_PRIV_REC_NEXT(732, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_732(choice, ...) ML99_PRIV_REC_NEXT(733, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_733(choice, ...) ML99_PRIV_REC_NEXT(734, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_734(choice, ...) ML99_PRIV_REC_NEXT(735, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_735(choice, ...) ML99_PRIV_REC_NEXT(736, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_736(choice, ...) ML99_PRIV_REC_NEXT(737, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_737(choice, ...) ML99_PRIV_REC_NEXT(738, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_738(choice, ...) ML99_PRIV_REC_NEXT(739, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_739(choice, ...) ML99_PRIV_REC_NEXT(740, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_740(choice, ...) ML99_PRIV_REC_NEXT(741, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_741(choice, ...) ML99_PRIV_REC_NEXT(742, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_742(choice, ...) ML99_PRIV_REC_NEXT(743, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_743(choice, ...) ML99_PRIV_REC_NEXT(744, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_744(choice, ...) ML99_PRIV_REC_NEXT(745, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_745(choice, ...) ML99_PRIV_REC_NEXT(746, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_746(choice, ...) ML99_PRIV_REC_NEXT(747, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_747(choice, ...) ML99_PRIV_REC_NEXT(748, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_748(choice, ...) ML99_PRIV_REC_NEXT(749, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_749(choice, ...) ML99_PRIV_REC_NEXT(750, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_750(choice, ...) ML99_PRIV_REC_NEXT(751, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_751(choice, ...) ML99_PRIV_REC_NEXT(752, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_752(choice, ...) ML99_PRIV_REC_NEXT(753, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_753(choice, ...) ML99_PRIV_REC_NEXT(754, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_754(choice, ...) ML99_PRIV_REC_NEXT(755, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_755(choice, ...) ML99_PRIV_REC_NEXT(756, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_756(choice, ...) ML99_PRIV_REC_NEXT(757, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_757(choice, ...) ML99_PRIV_REC_NEXT(758, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_758(choice, ...) ML99_PRIV_REC_NEXT(759, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_759(choice, ...) ML99_PRIV_REC_NEXT(760, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_760(choice, ...) ML99_PRIV_REC_NEXT(761, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_761(choice, ...) ML99_PRIV_REC_NEXT(762, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_762(choice, ...) ML99_PRIV_REC_NEXT(763, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_763(choice, ...) ML99_PRIV_REC_NEXT(764, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_764(choice, ...) ML99_PRIV_REC_NEXT(765, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_765(choice, ...) ML99_PRIV_REC_NEXT(766, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_766(choice, ...) ML99_PRIV_REC_NEXT(767, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_767(choice, ...) ML99_PRIV_REC_NEXT(768, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_768(choice, ...) ML99_PRIV_REC_NEXT(769, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_769(choice, ...) ML99_PRIV_REC_NEXT(770, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_770(choice, ...) ML99_PRIV_REC_NEXT(771, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_771(choice, ...) ML99_PRIV_REC_NEXT(772, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_772(choice, ...) ML99_PRIV_REC_NEXT(773, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_773(choice, ...) ML99_PRIV_REC_NEXT(774, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_774(choice, ...) ML99_PRIV_REC_NEXT(775, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_775(choice, ...) ML99_PRIV_REC_NEXT(776, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_776(choice, ...) ML99_PRIV_REC_NEXT(777, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_777(choice, ...) ML99_PRIV_REC_NEXT(778, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_778(choice, ...) ML99_PRIV_REC_NEXT(779, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_779(choice, ...) ML99_PRIV_REC_NEXT(780, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_780(choice, ...) ML99_PRIV_REC_NEXT(781, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_781(choice, ...) ML99_PRIV_REC_NEXT(782, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_782(choice, ...) ML99_PRIV_REC_NEXT(783, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_783(choice, ...) ML99_PRIV_REC_NEXT(784, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_784(choice, ...) ML99_PRIV_REC_NEXT(785, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_785(choice, ...) ML99_PRIV_REC_NEXT(786, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_786(choice, ...) ML99_PRIV_REC_NEXT(787, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_787(choice, ...) ML99_PRIV_REC_NEXT(788, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_788(choice, ...) ML99_PRIV_REC_NEXT(789, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_789(choice, ...) ML99_PRIV_REC_NEXT(790, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_790(choice, ...) ML99_PRIV_REC_NEXT(791, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_791(choice, ...) ML99_PRIV_REC_NEXT(792, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_792(choice, ...) ML99_PRIV_REC_NEXT(793, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_793(choice, ...) ML99_PRIV_REC_NEXT(794, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_794(choice, ...) ML99_PRIV_REC_NEXT(795, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_795(choice, ...) ML99_PRIV_REC_NEXT(796, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_796(choice, ...) ML99_PRIV_REC_NEXT(797, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_797(choice, ...) ML99_PRIV_REC_NEXT(798, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_798(choice, ...) ML99_PRIV_REC_NEXT(799, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_799(choice, ...) ML99_PRIV_REC_NEXT(800, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_800(choice, ...) ML99_PRIV_REC_NEXT(801, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_801(choice, ...) ML99_PRIV_REC_NEXT(802, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_802(choice, ...) ML99_PRIV_REC_NEXT(803, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_803(choice, ...) ML99_PRIV_REC_NEXT(804, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_804(choice, ...) ML99_PRIV_REC_NEXT(805, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_805(choice, ...) ML99_PRIV_REC_NEXT(806, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_806(choice, ...) ML99_PRIV_REC_NEXT(807, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_807(choice, ...) ML99_PRIV_REC_NEXT(808, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_808(choice, ...) ML99_PRIV_REC_NEXT(809, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_809(choice, ...) ML99_PRIV_REC_NEXT(810, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_810(choice, ...) ML99_PRIV_REC_NEXT(811, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_811(choice, ...) ML99_PRIV_REC_NEXT(812, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_812(choice, ...) ML99_PRIV_REC_NEXT(813, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_813(choice, ...) ML99_PRIV_REC_NEXT(814, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_814(choice, ...) ML99_PRIV_REC_NEXT(815, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_815(choice, ...) ML99_PRIV_REC_NEXT(816, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_816(choice, ...) ML99_PRIV_REC_NEXT(817, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_817(choice, ...) ML99_PRIV_REC_NEXT(818, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_818(choice, ...) ML99_PRIV_REC_NEXT(819, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_819(choice, ...) ML99_PRIV_REC_NEXT(820, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_820(choice, ...) ML99_PRIV_REC_NEXT(821, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_821(choice, ...) ML99_PRIV_REC_NEXT(822, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_822(choice, ...) ML99_PRIV_REC_NEXT(823, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_823(choice, ...) ML99_PRIV_REC_NEXT(824, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_824(choice, ...) ML99_PRIV_REC_NEXT(825, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_825(choice, ...) ML99_PRIV_REC_NEXT(826, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_826(choice, ...) ML99_PRIV_REC_NEXT(827, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_827(choice, ...) ML99_PRIV_REC_NEXT(828, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_828(choice, ...) ML99_PRIV_REC_NEXT(829, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_829(choice, ...) ML99_PRIV_REC_NEXT(830, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_830(choice, ...) ML99_PRIV_REC_NEXT(831, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_831(choice, ...) ML99_PRIV_REC_NEXT(832, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_832(choice, ...) ML99_PRIV_REC_NEXT(833, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_833(choice, ...) ML99_PRIV_REC_NEXT(834, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_834(choice, ...) ML99_PRIV_REC_NEXT(835, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_835(choice, ...) ML99_PRIV_REC_NEXT(836, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_836(choice, ...) ML99_PRIV_REC_NEXT(837, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_837(choice, ...) ML99_PRIV_REC_NEXT(838, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_838(choice, ...) ML99_PRIV_REC_NEXT(839, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_839(choice, ...) ML99_PRIV_REC_NEXT(840, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_840(choice, ...) ML99_PRIV_REC_NEXT(841, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_841(choice, ...) ML99_PRIV_REC_NEXT(842, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_842(choice, ...) ML99_PRIV_REC_NEXT(843, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_843(choice, ...) ML99_PRIV_REC_NEXT(844, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_844(choice, ...) ML99_PRIV_REC_NEXT(845, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_845(choice, ...) ML99_PRIV_REC_NEXT(846, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_846(choice, ...) ML99_PRIV_REC_NEXT(847, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_847(choice, ...) ML99_PRIV_REC_NEXT(848, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_848(choice, ...) ML99_PRIV_REC_NEXT(849, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_849(choice, ...) ML99_PRIV_REC_NEXT(850, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_850(choice, ...) ML99_PRIV_REC_NEXT(851, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_851(choice, ...) ML99_PRIV_REC_NEXT(852, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_852(choice, ...) ML99_PRIV_REC_NEXT(853, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_853(choice, ...) ML99_PRIV_REC_NEXT(854, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_854(choice, ...) ML99_PRIV_REC_NEXT(855, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_855(choice, ...) ML99_PRIV_REC_NEXT(856, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_856(choice, ...) ML99_PRIV_REC_NEXT(857, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_857(choice, ...) ML99_PRIV_REC_NEXT(858, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_858(choice, ...) ML99_PRIV_REC_NEXT(859, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_859(choice, ...) ML99_PRIV_REC_NEXT(860, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_860(choice, ...) ML99_PRIV_REC_NEXT(861, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_861(choice, ...) ML99_PRIV_REC_NEXT(862, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_862(choice, ...) ML99_PRIV_REC_NEXT(863, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_863(choice, ...) ML99_PRIV_REC_NEXT(864, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_864(choice, ...) ML99_PRIV_REC_NEXT(865, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_865(choice, ...) ML99_PRIV_REC_NEXT(866, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_866(choice, ...) ML99_PRIV_REC_NEXT(867, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_867(choice, ...) ML99_PRIV_REC_NEXT(868, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_868(choice, ...) ML99_PRIV_REC_NEXT(869, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_869(choice, ...) ML99_PRIV_REC_NEXT(870, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_870(choice, ...) ML99_PRIV_REC_NEXT(871, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_871(choice, ...) ML99_PRIV_REC_NEXT(872, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_872(choice, ...) ML99_PRIV_REC_NEXT(873, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_873(choice, ...) ML99_PRIV_REC_NEXT(874, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_874(choice, ...) ML99_PRIV_REC_NEXT(875, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_875(choice, ...) ML99_PRIV_REC_NEXT(876, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_876(choice, ...) ML99_PRIV_REC_NEXT(877, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_877(choice, ...) ML99_PRIV_REC_NEXT(878, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_878(choice, ...) ML99_PRIV_REC_NEXT(879, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_879(choice, ...) ML99_PRIV_REC_NEXT(880, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_880(choice, ...) ML99_PRIV_REC_NEXT(881, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_881(choice, ...) ML99_PRIV_REC_NEXT(882, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_882(choice, ...) ML99_PRIV_REC_NEXT(883, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_883(choice, ...) ML99_PRIV_REC_NEXT(884, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_884(choice, ...) ML99_PRIV_REC_NEXT(885, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_885(choice, ...) ML99_PRIV_REC_NEXT(886, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_886(choice, ...) ML99_PRIV_REC_NEXT(887, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_887(choice, ...) ML99_PRIV_REC_NEXT(888, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_888(choice, ...) ML99_PRIV_REC_NEXT(889, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_889(choice, ...) ML99_PRIV_REC_NEXT(890, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_890(choice, ...) ML99_PRIV_REC_NEXT(891, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_891(choice, ...) ML99_PRIV_REC_NEXT(892, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_892(choice, ...) ML99_PRIV_REC_NEXT(893, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_893(choice, ...) ML99_PRIV_REC_NEXT(894, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_894(choice, ...) ML99_PRIV_REC_NEXT(895, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_895(choice, ...) ML99_PRIV_REC_NEXT(896, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_896(choice, ...) ML99_PRIV_REC_NEXT(897, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_897(choice, ...) ML99_PRIV_REC_NEXT(898, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_898(choice, ...) ML99_PRIV_REC_NEXT(899, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_899(choice, ...) ML99_PRIV_REC_NEXT(900, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_900(choice, ...) ML99_PRIV_REC_NEXT(901, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_901(choice, ...) ML99_PRIV_REC_NEXT(902, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_902(choice, ...) ML99_PRIV_REC_NEXT(903, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_903(choice, ...) ML99_PRIV_REC_NEXT(904, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_904(choice, ...) ML99_PRIV_REC_NEXT(905, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_905(choice, ...) ML99_PRIV_REC_NEXT(906, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_906(choice, ...) ML99_PRIV_REC_NEXT(907, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_907(choice, ...) ML99_PRIV_REC_NEXT(908, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_908(choice, ...) ML99_PRIV_REC_NEXT(909, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_909(choice, ...) ML99_PRIV_REC_NEXT(910, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_910(choice, ...) ML99_PRIV_REC_NEXT(911, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_911(choice, ...) ML99_PRIV_REC_NEXT(912, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_912(choice, ...) ML99_PRIV_REC_NEXT(913, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_913(choice, ...) ML99_PRIV_REC_NEXT(914, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_914(choice, ...) ML99_PRIV_REC_NEXT(915, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_915(choice, ...) ML99_PRIV_REC_NEXT(916, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_916(choice, ...) ML99_PRIV_REC_NEXT(917, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_917(choice, ...) ML99_PRIV_REC_NEXT(918, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_918(choice, ...) ML99_PRIV_REC_NEXT(919, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_919(choice, ...) ML99_PRIV_REC_NEXT(920, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_920(choice, ...) ML99_PRIV_REC_NEXT(921, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_921(choice, ...) ML99_PRIV_REC_NEXT(922, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_922(choice, ...) ML99_PRIV_REC_NEXT(923, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_923(choice, ...) ML99_PRIV_REC_NEXT(924, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_924(choice, ...) ML99_PRIV_REC_NEXT(925, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_925(choice, ...) ML99_PRIV_REC_NEXT(926, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_926(choice, ...) ML99_PRIV_REC_NEXT(927, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_927(choice, ...) ML99_PRIV_REC_NEXT(928, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_928(choice, ...) ML99_PRIV_REC_NEXT(929, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_929(choice, ...) ML99_PRIV_REC_NEXT(930, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_930(choice, ...) ML99_PRIV_REC_NEXT(931, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_931(choice, ...) ML99_PRIV_REC_NEXT(932, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_932(choice, ...) ML99_PRIV_REC_NEXT(933, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_933(choice, ...) ML99_PRIV_REC_NEXT(934, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_934(choice, ...) ML99_PRIV_REC_NEXT(935, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_935(choice, ...) ML99_PRIV_REC_NEXT(936, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_936(choice, ...) ML99_PRIV_REC_NEXT(937, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_937(choice, ...) ML99_PRIV_REC_NEXT(938, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_938(choice, ...) ML99_PRIV_REC_NEXT(939, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_939(choice, ...) ML99_PRIV_REC_NEXT(940, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_940(choice, ...) ML99_PRIV_REC_NEXT(941, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_941(choice, ...) ML99_PRIV_REC_NEXT(942, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_942(choice, ...) ML99_PRIV_REC_NEXT(943, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_943(choice, ...) ML99_PRIV_REC_NEXT(944, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_944(choice, ...) ML99_PRIV_REC_NEXT(945, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_945(choice, ...) ML99_PRIV_REC_NEXT(946, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_946(choice, ...) ML99_PRIV_REC_NEXT(947, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_947(choice, ...) ML99_PRIV_REC_NEXT(948, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_948(choice, ...) ML99_PRIV_REC_NEXT(949, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_949(choice, ...) ML99_PRIV_REC_NEXT(950, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_950(choice, ...) ML99_PRIV_REC_NEXT(951, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_951(choice, ...) ML99_PRIV_REC_NEXT(952, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_952(choice, ...) ML99_PRIV_REC_NEXT(953, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_953(choice, ...) ML99_PRIV_REC_NEXT(954, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_954(choice, ...) ML99_PRIV_REC_NEXT(955, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_955(choice, ...) ML99_PRIV_REC_NEXT(956, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_956(choice, ...) ML99_PRIV_REC_NEXT(957, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_957(choice, ...) ML99_PRIV_REC_NEXT(958, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_958(choice, ...) ML99_PRIV_REC_NEXT(959, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_959(choice, ...) ML99_PRIV_REC_NEXT(960, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_960(choice, ...) ML99_PRIV_REC_NEXT(961, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_961(choice, ...) ML99_PRIV_REC_NEXT(962, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_962(choice, ...) ML99_PRIV_REC_NEXT(963, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_963(choice, ...) ML99_PRIV_REC_NEXT(964, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_964(choice, ...) ML99_PRIV_REC_NEXT(965, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_965(choice, ...) ML99_PRIV_REC_NEXT(966, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_966(choice, ...) ML99_PRIV_REC_NEXT(967, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_967(choice, ...) ML99_PRIV_REC_NEXT(968, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_968(choice, ...) ML99_PRIV_REC_NEXT(969, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_969(choice, ...) ML99_PRIV_REC_NEXT(970, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_970(choice, ...) ML99_PRIV_REC_NEXT(971, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_971(choice, ...) ML99_PRIV_REC_NEXT(972, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_972(choice, ...) ML99_PRIV_REC_NEXT(973, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_973(choice, ...) ML99_PRIV_REC_NEXT(974, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_974(choice, ...) ML99_PRIV_REC_NEXT(975, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_975(choice, ...) ML99_PRIV_REC_NEXT(976, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_976(choice, ...) ML99_PRIV_REC_NEXT(977, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_977(choice, ...) ML99_PRIV_REC_NEXT(978, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_978(choice, ...) ML99_PRIV_REC_NEXT(979, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_979(choice, ...) ML99_PRIV_REC_NEXT(980, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_980(choice, ...) ML99_PRIV_REC_NEXT(981, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_981(choice, ...) ML99_PRIV_REC_NEXT(982, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_982(choice, ...) ML99_PRIV_REC_NEXT(983, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_983(choice, ...) ML99_PRIV_REC_NEXT(984, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_984(choice, ...) ML99_PRIV_REC_NEXT(985, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_985(choice, ...) ML99_PRIV_REC_NEXT(986, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_986(choice, ...) ML99_PRIV_REC_NEXT(987, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_987(choice, ...) ML99_PRIV_REC_NEXT(988, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_988(choice, ...) ML99_PRIV_REC_NEXT(989, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_989(choice, ...) ML99_PRIV_REC_NEXT(990, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_990(choice, ...) ML99_PRIV_REC_NEXT(991, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_991(choice, ...) ML99_PRIV_REC_NEXT(992, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_992(choice, ...) ML99_PRIV_REC_NEXT(993, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_993(choice, ...) ML99_PRIV_REC_NEXT(994, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_994(choice, ...) ML99_PRIV_REC_NEXT(995, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_995(choice, ...) ML99_PRIV_REC_NEXT(996, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_996(choice, ...) ML99_PRIV_REC_NEXT(997, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_997(choice, ...) ML99_PRIV_REC_NEXT(998, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_998(choice, ...) ML99_PRIV_REC_NEXT(999, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_999(choice, ...) ML99_PRIV_REC_NEXT(1000, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1000(choice, ...) ML99_PRIV_REC_NEXT(1001, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1001(choice, ...) ML99_PRIV_REC_NEXT(1002, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1002(choice, ...) ML99_PRIV_REC_NEXT(1003, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1003(choice, ...) ML99_PRIV_REC_NEXT(1004, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1004(choice, ...) ML99_PRIV_REC_NEXT(1005, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1005(choice, ...) ML99_PRIV_REC_NEXT(1006, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1006(choice, ...) ML99_PRIV_REC_NEXT(1007, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1007(choice, ...) ML99_PRIV_REC_NEXT(1008, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1008(choice, ...) ML99_PRIV_REC_NEXT(1009, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1009(choice, ...) ML99_PRIV_REC_NEXT(1010, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1010(choice, ...) ML99_PRIV_REC_NEXT(1011, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1011(choice, ...) ML99_PRIV_REC_NEXT(1012, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1012(choice, ...) ML99_PRIV_REC_NEXT(1013, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1013(choice, ...) ML99_PRIV_REC_NEXT(1014, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1014(choice, ...) ML99_PRIV_REC_NEXT(1015, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1015(choice, ...) ML99_PRIV_REC_NEXT(1016, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1016(choice, ...) ML99_PRIV_REC_NEXT(1017, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1017(choice, ...) ML99_PRIV_REC_NEXT(1018, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1018(choice, ...) ML99_PRIV_REC_NEXT(1019, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1019(choice, ...) ML99_PRIV_REC_NEXT(1020, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1020(choice, ...) ML99_PRIV_REC_NEXT(1021, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1021(choice, ...) ML99_PRIV_REC_NEXT(1022, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1022(choice, ...) ML99_PRIV_REC_NEXT(1023, choice)(__VA_ARGS__) +#define ML99_PRIV_REC_1023 ML99_PRIV_REC_DEFER(ML99_PRIV_REC_0_HOOK)() + +#define ML99_PRIV_REC_0_HOOK() ML99_PRIV_REC_0 + +#endif // ML99_EVAL_REC_H diff --git a/test/external/metalang99/include/metalang99/eval/syntax_checker.h b/test/external/metalang99/include/metalang99/eval/syntax_checker.h new file mode 100644 index 0000000..0f87bef --- /dev/null +++ b/test/external/metalang99/include/metalang99/eval/syntax_checker.h @@ -0,0 +1,42 @@ +#ifndef ML99_EVAL_SYNTAX_CHECKER_H +#define ML99_EVAL_SYNTAX_CHECKER_H + +#include <metalang99/priv/bool.h> +#include <metalang99/priv/compiler_specific.h> +#include <metalang99/priv/tuple.h> +#include <metalang99/priv/util.h> + +#include <metalang99/eval/rec.h> + +#define ML99_PRIV_CHECK_TERM(term, default) \ + ML99_PRIV_IF(ML99_PRIV_IS_UNTUPLE(term), ML99_PRIV_EMIT_SYNTAX_ERROR, default) + +// clang-format off +#define ML99_PRIV_EMIT_SYNTAX_ERROR(term) \ + ML99_PRIV_REC_CONTINUE(ML99_PRIV_REC_STOP)((~), ML99_PRIV_SYNTAX_ERROR(term)) \ + /* Consume arguments passed to ML99_PRIV_TERM_MATCH, see eval.h. */ \ + ML99_PRIV_EMPTY +// clang-format on + +#define ML99_PRIV_SYNTAX_ERROR(invalid_term) \ + ML99_PRIV_CAT(ML99_PRIV_SYNTAX_ERROR_, ML99_PRIV_IS_DOUBLE_TUPLE_BEGINNING(invalid_term)) \ + (invalid_term) + +#ifdef ML99_PRIV_EMIT_ERROR + +#define ML99_PRIV_SYNTAX_ERROR_0(invalid_term) \ + ML99_PRIV_EMIT_ERROR("invalid term `" #invalid_term "`"); +#define ML99_PRIV_SYNTAX_ERROR_1(invalid_term) \ + ML99_PRIV_EMIT_ERROR("invalid term `" #invalid_term "`, did you miss a comma?"); + +#else + +// clang-format off +#define ML99_PRIV_SYNTAX_ERROR_0(invalid_term) !"Metalang99 syntax error": {invalid_term} +#define ML99_PRIV_SYNTAX_ERROR_1(invalid_term) \ + !"Metalang99 syntax error (did you miss a comma?)": {invalid_term} +// clang-format on + +#endif + +#endif // ML99_EVAL_SYNTAX_CHECKER_H diff --git a/test/external/metalang99/include/metalang99/gen.h b/test/external/metalang99/include/metalang99/gen.h new file mode 100644 index 0000000..dbb7ca8 --- /dev/null +++ b/test/external/metalang99/include/metalang99/gen.h @@ -0,0 +1,407 @@ +/** + * @file + * Support for C language constructions. + * + * Some decent usage examples can be found in + * [datatype99/examples/derive](https://github.com/hirrolot/datatype99/tree/master/examples/derive). + */ + +#ifndef ML99_GEN_H +#define ML99_GEN_H + +#include <metalang99/priv/bool.h> + +#include <metalang99/choice.h> +#include <metalang99/lang.h> +#include <metalang99/list.h> +#include <metalang99/nat.h> +#include <metalang99/tuple.h> +#include <metalang99/variadics.h> + +#include <metalang99/stmt.h> // For backwards compatibility. +#include <metalang99/util.h> // For backwards compatibility: ML99_GEN_SYM, ML99_TRAILING_SEMICOLON. + +/** + * Puts a semicolon after provided arguments. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * + * // int x = 5; + * ML99_semicoloned(v(int x = 5)) + * @endcode + */ +#define ML99_semicoloned(...) ML99_call(ML99_semicoloned, __VA_ARGS__) + +/** + * Puts provided arguments into braces. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * + * // { int a, b, c; } + * ML99_braced(v(int a, b, c;)) + * @endcode + */ +#define ML99_braced(...) ML99_call(ML99_braced, __VA_ARGS__) + +/** + * Generates an assignment of provided variadic arguments to @p lhs. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * + * // x = 5, 6, 7 + * ML99_assign(v(x), v(5, 6, 7)) + * @endcode + */ +#define ML99_assign(lhs, ...) ML99_call(ML99_assign, lhs, __VA_ARGS__) + +/** + * A shortcut for `ML99_assign(lhs, ML99_braced(...))`. + */ +#define ML99_assignInitializerList(lhs, ...) ML99_call(ML99_assignInitializerList, lhs, __VA_ARGS__) + +/** + * A shortcut for `ML99_semicoloned(ML99_assign(lhs, ...))`. + */ +#define ML99_assignStmt(lhs, ...) ML99_call(ML99_assignStmt, lhs, __VA_ARGS__) + +/** + * A shortcut for `ML99_assignStmt(lhs, ML99_braced(...))`. + */ +#define ML99_assignInitializerListStmt(lhs, ...) \ + ML99_call(ML99_assignInitializerListStmt, lhs, __VA_ARGS__) + +/** + * Generates a function/macro invocation. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * + * // If you are on C11. + * ML99_invoke(v(_Static_assert), v(1 == 1, "Must be true")) + * @endcode + */ +#define ML99_invoke(f, ...) ML99_call(ML99_invoke, f, __VA_ARGS__) + +/** + * A shortcut for `ML99_semicoloned(ML99_invoke(f, ...))`. + */ +#define ML99_invokeStmt(f, ...) ML99_call(ML99_invokeStmt, f, __VA_ARGS__) + +/** + * Generates `prefix { code }`. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * + * // if (1 == 1) { + * // printf("x = %d\n", x); + * // } + * ML99_prefixedBlock(v(if (1 == 1)), v(printf("x = %d\n", x);)) + * @endcode + */ +#define ML99_prefixedBlock(prefix, ...) ML99_call(ML99_prefixedBlock, prefix, __VA_ARGS__) + +/** + * Generates a type definition. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * + * // typedef struct { int x, y; } Point; + * ML99_typedef(v(Point), v(struct { int x, y; })) + * @endcode + */ +#define ML99_typedef(ident, ...) ML99_call(ML99_typedef, ident, __VA_ARGS__) + +/** + * Generates a C structure. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * + * // struct Point { int x, y; } + * ML99_struct(v(Point), v(int x, y;)) + * @endcode + */ +#define ML99_struct(ident, ...) ML99_call(ML99_struct, ident, __VA_ARGS__) + +/** + * Generates an anonymous C structure. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * + * // struct { int x, y; } + * ML99_struct(v(int x, y;)) + * @endcode + */ +#define ML99_anonStruct(...) ML99_call(ML99_anonStruct, __VA_ARGS__) + +/** + * The same as #ML99_struct but generates a union. + */ +#define ML99_union(ident, ...) ML99_call(ML99_union, ident, __VA_ARGS__) + +/** + * The same as #ML99_anonStruct but generates a union. + */ +#define ML99_anonUnion(...) ML99_call(ML99_anonUnion, __VA_ARGS__) + +/** + * The same as #ML99_struct but generates an enumeration. + */ +#define ML99_enum(ident, ...) ML99_call(ML99_enum, ident, __VA_ARGS__) + +/** + * The same as #ML99_anonStruct but generates an enumeration. + */ +#define ML99_anonEnum(...) ML99_call(ML99_anonEnum, __VA_ARGS__) + +/** + * Generates a function pointer. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * + * // int (*add)(int x, int y) + * ML99_fnPtr(v(int), v(add), v(int x), v(int y)) + * + * // const char *(*title)(void) + * ML99_fnPtr(v(const char *), v(title), v(void)) + * @endcode + */ +#define ML99_fnPtr(ret_ty, name, ...) ML99_call(ML99_fnPtr, ret_ty, name, __VA_ARGS__) + +/** + * A shortcut for `ML99_semicoloned(ML99_fnPtr(ret_ty, name, ...))`. + */ +#define ML99_fnPtrStmt(ret_ty, name, ...) ML99_call(ML99_fnPtrStmt, ret_ty, name, __VA_ARGS__) + +/** + * Pastes provided arguments @p n times. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * + * // ~ ~ ~ ~ ~ + * ML99_times(v(5), v(~)) + * @endcode + */ +#define ML99_times(n, ...) ML99_call(ML99_times, n, __VA_ARGS__) + +/** + * Invokes @p f @p n times, providing an iteration index each time. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * #include <metalang99/util.h> + * + * // _0 _1 _2 + * ML99_repeat(v(3), ML99_appl(v(ML99_cat), v(_))) + * @endcode + */ +#define ML99_repeat(n, f) ML99_call(ML99_repeat, n, f) + +/** + * Generates \f$(T_0 \ \_0, ..., T_n \ \_n)\f$. + * + * If @p type_list is empty, this macro results in `(void)`. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * + * // (int _0, long long _1, const char * _2) + * ML99_indexedParams(ML99_list(v(int, long long, const char *))) + * + * // (void) + * ML99_indexedParams(ML99_nil()) + * @endcode + */ +#define ML99_indexedParams(type_list) ML99_call(ML99_indexedParams, type_list) + +/** + * Generates \f$T_0 \ \_0; ...; T_n \ \_n\f$. + * + * If @p type_list is empty, this macro results in emptiness. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * + * // int _0; long long _1; const char * _2; + * ML99_indexedFields(ML99_list(v(int, long long, const char *))) + * + * // ML99_empty() + * ML99_indexedFields(ML99_nil()) + * @endcode + */ +#define ML99_indexedFields(type_list) ML99_call(ML99_indexedFields, type_list) + +/** + * Generates \f$\{ \_0, ..., \_{n - 1} \}\f$. + * + * If @p n is 0, this macro results in `{ 0 }`. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * + * // { _0, _1, _2 } + * ML99_indexedInitializerList(v(3)) + * + * // { 0 } + * ML99_indexedInitializerList(v(0)) + * @endcode + */ +#define ML99_indexedInitializerList(n) ML99_call(ML99_indexedInitializerList, n) + +/** + * Generates \f$\_0, ..., \_{n - 1}\f$. + * + * If @p n is 0, this macro results in emptiness. + * + * # Examples + * + * @code + * #include <metalang99/gen.h> + * + * // _0, _1, _2 + * ML99_indexedArgs(v(3)) + * + * // ML99_empty() + * ML99_indexedArgs(v(0)) + * @endcode + */ +#define ML99_indexedArgs(n) ML99_call(ML99_indexedArgs, n) + +#ifndef DOXYGEN_IGNORE + +#define ML99_semicoloned_IMPL(...) v(__VA_ARGS__;) +#define ML99_braced_IMPL(...) v({__VA_ARGS__}) +#define ML99_assign_IMPL(lhs, ...) v(lhs = __VA_ARGS__) +#define ML99_assignStmt_IMPL(lhs, ...) v(lhs = __VA_ARGS__;) +#define ML99_assignInitializerList_IMPL(lhs, ...) v(lhs = {__VA_ARGS__}) +#define ML99_assignInitializerListStmt_IMPL(lhs, ...) v(lhs = {__VA_ARGS__};) +#define ML99_invoke_IMPL(f, ...) v(f(__VA_ARGS__)) +#define ML99_invokeStmt_IMPL(f, ...) v(f(__VA_ARGS__);) +#define ML99_typedef_IMPL(ident, ...) v(typedef __VA_ARGS__ ident;) +#define ML99_fnPtr_IMPL(ret_ty, name, ...) v(ret_ty (*name)(__VA_ARGS__)) +#define ML99_fnPtrStmt_IMPL(ret_ty, name, ...) v(ret_ty (*name)(__VA_ARGS__);) + +// clang-format off +#define ML99_prefixedBlock_IMPL(prefix, ...) v(prefix {__VA_ARGS__}) +#define ML99_struct_IMPL(ident, ...) v(struct ident {__VA_ARGS__}) +#define ML99_anonStruct_IMPL(...) v(struct {__VA_ARGS__}) +#define ML99_union_IMPL(ident, ...) v(union ident {__VA_ARGS__}) +#define ML99_anonUnion_IMPL(...) v(union {__VA_ARGS__}) +#define ML99_enum_IMPL(ident, ...) v(enum ident {__VA_ARGS__}) +#define ML99_anonEnum_IMPL(...) v(enum {__VA_ARGS__}) +// clang-format on + +#define ML99_times_IMPL(n, ...) ML99_natMatchWithArgs_IMPL(n, ML99_PRIV_times_, __VA_ARGS__) +#define ML99_PRIV_times_Z_IMPL ML99_empty_IMPL +#define ML99_PRIV_times_S_IMPL(i, ...) ML99_TERMS(v(__VA_ARGS__), ML99_times_IMPL(i, __VA_ARGS__)) + +#define ML99_repeat_IMPL(n, f) ML99_natMatchWithArgs_IMPL(n, ML99_PRIV_repeat_, f) +#define ML99_PRIV_repeat_Z_IMPL ML99_empty_IMPL +#define ML99_PRIV_repeat_S_IMPL(i, f) ML99_TERMS(ML99_repeat_IMPL(i, f), ML99_appl_IMPL(f, i)) + +// ML99_indexedParams_IMPL { + +#define ML99_indexedParams_IMPL(type_list) \ + ML99_tuple(ML99_PRIV_IF( \ + ML99_IS_NIL(type_list), \ + v(void), \ + ML99_variadicsTail(ML99_PRIV_indexedParamsAux_IMPL(type_list, 0)))) + +#define ML99_PRIV_indexedParamsAux_IMPL(type_list, i) \ + ML99_matchWithArgs_IMPL(type_list, ML99_PRIV_indexedParams_, i) +#define ML99_PRIV_indexedParams_nil_IMPL ML99_empty_IMPL +#define ML99_PRIV_indexedParams_cons_IMPL(x, xs, i) \ + ML99_TERMS(v(, x _##i), ML99_PRIV_indexedParamsAux_IMPL(xs, ML99_INC(i))) +// } (ML99_indexedParams_IMPL) + +// ML99_indexedFields_IMPL { + +#define ML99_indexedFields_IMPL(type_list) ML99_PRIV_indexedFieldsAux_IMPL(type_list, 0) + +#define ML99_PRIV_indexedFieldsAux_IMPL(type_list, i) \ + ML99_matchWithArgs_IMPL(type_list, ML99_PRIV_indexedFields_, i) +#define ML99_PRIV_indexedFields_nil_IMPL ML99_empty_IMPL +#define ML99_PRIV_indexedFields_cons_IMPL(x, xs, i) \ + ML99_TERMS(v(x _##i;), ML99_PRIV_indexedFieldsAux_IMPL(xs, ML99_INC(i))) +// } (ML99_indexedFields_IMPL) + +#define ML99_indexedInitializerList_IMPL(n) ML99_braced(ML99_PRIV_INDEXED_ITEMS(n, v(0))) +#define ML99_indexedArgs_IMPL(n) ML99_PRIV_INDEXED_ITEMS(n, v(ML99_EMPTY())) + +#define ML99_PRIV_INDEXED_ITEMS(n, empty_case) \ + ML99_PRIV_IF( \ + ML99_NAT_EQ(n, 0), \ + empty_case, \ + ML99_variadicsTail(ML99_repeat_IMPL(n, ML99_PRIV_indexedItem))) + +#define ML99_PRIV_indexedItem_IMPL(i) v(, _##i) + +// Arity specifiers { + +#define ML99_semicoloned_ARITY 1 +#define ML99_braced_ARITY 1 +#define ML99_assign_ARITY 2 +#define ML99_assignStmt_ARITY 2 +#define ML99_assignInitializerList_ARITY 2 +#define ML99_assignInitializerListStmt_ARITY 2 +#define ML99_invoke_ARITY 2 +#define ML99_invokeStmt_ARITY 2 +#define ML99_prefixedBlock_ARITY 2 +#define ML99_typedef_ARITY 2 +#define ML99_struct_ARITY 2 +#define ML99_anonStruct_ARITY 1 +#define ML99_union_ARITY 2 +#define ML99_anonUnion_ARITY 1 +#define ML99_enum_ARITY 2 +#define ML99_anonEnum_ARITY 1 +#define ML99_fnPtr_ARITY 3 +#define ML99_fnPtrStmt_ARITY 3 +#define ML99_repeat_ARITY 2 +#define ML99_times_ARITY 2 +#define ML99_indexedParams_ARITY 1 +#define ML99_indexedFields_ARITY 1 +#define ML99_indexedInitializerList_ARITY 1 +#define ML99_indexedArgs_ARITY 1 + +#define ML99_PRIV_indexedItem_ARITY 1 +// } (Arity specifiers) + +#endif // DOXYGEN_IGNORE + +#endif // ML99_GEN_H diff --git a/test/external/metalang99/include/metalang99/ident.h b/test/external/metalang99/include/metalang99/ident.h new file mode 100644 index 0000000..f6bb67a --- /dev/null +++ b/test/external/metalang99/include/metalang99/ident.h @@ -0,0 +1,429 @@ +/** + * @file + * Identifiers: `[a-zA-Z0-9_]+`. + * + * An identifier is a sequence of characters. A character is one of: + * + * - digits (`0123456789`), + * - lowercase letters (`abcdefghijklmnopqrstuvwxyz`), + * - uppercase letters (`ABCDEFGHIJKLMNOPQRSTUVWXYZ`), + * - the underscore character (`_`). + * + * For example, here are identifiers: `_ak39A`, `192_iAjP_2`, `r9`. But these are **not** + * identifiers: `~18nA`, `o78*`, `3i#^hdd`. + */ + +#ifndef ML99_IDENT_H +#define ML99_IDENT_H + +#include <metalang99/priv/bool.h> +#include <metalang99/priv/tuple.h> +#include <metalang99/priv/util.h> + +#include <metalang99/lang.h> + +/** + * Tells whether @p ident belongs to a set of identifiers defined by @p prefix. + * + * If `ML99_cat(prefix, ident)` exists, it must be an object-like macro which expands to `()`. If + * so, `ML99_detectIdent(prefix, ident)` will expand to truth, otherwise (`ML99_cat(prefix, ident)` + * does **not** exist), `ML99_detectIdent(prefix, ident)` will expand to falsehood. + * + * # Predefined detectors + * + * - `ML99_UNDERSCORE_DETECTOR` detects the underscore character (`_`). + * + * # Examples + * + * @code + * #include <metalang99/ident.h> + * + * #define FOO_x () + * #define FOO_y () + * + * // 1 + * ML99_detectIdent(v(FOO_), v(x)) + * + * // 1 + * ML99_detectIdent(v(FOO_), v(y)) + * + * // 0 + * ML99_detectIdent(v(FOO_), v(z)) + * + * // 1 + * ML99_detectIdent(v(ML99_UNDERSCORE_DETECTOR), v(_)) + * @endcode + */ +#define ML99_detectIdent(prefix, ident) ML99_call(ML99_detectIdent, prefix, ident) + +/** + * Compares two identifiers @p x and @p y for equality. + * + * This macro is a shortcut to `ML99_detectIdent(ML99_cat3(prefix, x, v(_)), y)`. + * + * # Predefined detectors + * + * - `ML99_C_KEYWORD_DETECTOR` detects all the [C11 + * keywords](https://en.cppreference.com/w/c/keyword). + * - `ML99_LOWERCASE_DETECTOR` detects lowercase letters (`abcdefghijklmnopqrstuvwxyz`). + * - `ML99_UPPERCASE_DETECTOR` detects uppercase letters (`ABCDEFGHIJKLMNOPQRSTUVWXYZ`). + * - `ML99_DIGIT_DETECTOR` detects digits (`0123456789`). + * + * # Examples + * + * @code + * #include <metalang99/ident.h> + * + * #define FOO_x_x () + * #define FOO_y_y () + * + * // 1 + * ML99_identEq(v(FOO_), v(x), v(x)) + * + * // 1 + * ML99_identEq(v(FOO_), v(y), v(y)) + * + * // 0 + * ML99_identEq(v(FOO_), v(x), v(y)) + * + * // 1 + * ML99_identEq(v(ML99_C_KEYWORD_DETECTOR), v(while), v(while)) + * ML99_identEq(v(ML99_LOWERCASE_DETECTOR), v(x), v(x)) + * ML99_identEq(v(ML99_UPPERCASE_DETECTOR), v(X), v(X)) + * ML99_identEq(v(ML99_DIGIT_DETECTOR), v(5), v(5)) + * @endcode + */ +#define ML99_identEq(prefix, x, y) ML99_call(ML99_identEq, prefix, x, y) + +/** + * Compares two characters @p x and @p y for equality. + * + * @p x and @p y can be any identifiers, though this function evaluates to true only for characters. + * + * # Examples + * + * @code + * #include <metalang99/ident.h> + * + * // 1 + * ML99_charEq(v(t), v(t)) + * + * // 0 + * ML99_charEq(v(9), v(A)) + * + * // 0 + * ML99_charEq(v(9), v(abcd)) + * @endcode + */ +#define ML99_charEq(x, y) ML99_call(ML99_charEq, x, y) + +/** + * Tells whether the identifier @p x is a lowercase letter. + */ +#define ML99_isLowercase(x) ML99_call(ML99_isLowercase, x) + +/** + * Tells whether the identifier @p x is an uppercase letter. + */ +#define ML99_isUppercase(x) ML99_call(ML99_isUppercase, x) + +/** + * Tells whether the identifier @p x is a digit. + */ +#define ML99_isDigit(x) ML99_call(ML99_isDigit, x) + +/** + * Tells whether the identifier @p x is a character. + */ +#define ML99_isChar(x) ML99_call(ML99_isChar, x) + +/** + * Converts the Metalang99 character @p x to a C character literal. + * + * # Examples + * + * @code + * #include <metalang/ident.h> + * + * // 't' + * ML99_charLit(v(t)) + * + * // '9' + * ML99_charLit(v(9)) + * + * // '_' + * ML99_charLit(v(_)) + * @endcode + * + * @note The inverse of this function is impossible, i.e., you cannot get `q` from `'q'`. + */ +#define ML99_charLit(x) ML99_call(ML99_charLit, x) + +/** + * Expands to all comma-separated lowercase letters. + * + * This macro consumes all arguments. + * + * # Examples + * + * @code + * #include <metalang99/ident.h> + * #include <metalang99/variadics.h> + * + * #define F_IMPL(x) v([x]) + * #define F_ARITY 1 + * + * // [a] [b] [c] ... [x] [y] [z] + * ML99_variadicsForEach(v(F), v(ML99_LOWERCASE_CHARS())) + * @endcode + */ +#define ML99_LOWERCASE_CHARS(...) \ + a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z + +/** + * The same as #ML99_LOWERCASE_CHARS but for uppercase characters. + */ +#define ML99_UPPERCASE_CHARS(...) \ + A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z + +/** + * The same as #ML99_LOWERCASE_CHARS but for digits. + */ +#define ML99_DIGITS(...) 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 + +#define ML99_DETECT_IDENT(prefix, ident) ML99_PRIV_IS_TUPLE_FAST(ML99_PRIV_CAT(prefix, ident)) +#define ML99_IDENT_EQ(prefix, x, y) ML99_DETECT_IDENT(ML99_PRIV_CAT3(prefix, x, _), y) + +#define ML99_CHAR_EQ(x, y) \ + ML99_PRIV_IF( \ + ML99_DETECT_IDENT(ML99_UNDERSCORE_DETECTOR, x), \ + ML99_DETECT_IDENT(ML99_UNDERSCORE_DETECTOR, y), \ + ML99_PRIV_OR3( \ + ML99_IDENT_EQ(ML99_LOWERCASE_DETECTOR, x, y), \ + ML99_IDENT_EQ(ML99_UPPERCASE_DETECTOR, x, y), \ + ML99_IDENT_EQ(ML99_DIGIT_DETECTOR, x, y))) + +#define ML99_IS_LOWERCASE(x) ML99_IDENT_EQ(ML99_LOWERCASE_DETECTOR, x, x) +#define ML99_IS_UPPERCASE(x) ML99_IDENT_EQ(ML99_UPPERCASE_DETECTOR, x, x) +#define ML99_IS_DIGIT(x) ML99_IDENT_EQ(ML99_DIGIT_DETECTOR, x, x) + +#define ML99_IS_CHAR(x) \ + ML99_PRIV_OR4( \ + ML99_IS_LOWERCASE(x), \ + ML99_IS_UPPERCASE(x), \ + ML99_IS_DIGIT(x), \ + ML99_DETECT_IDENT(ML99_UNDERSCORE_DETECTOR, x)) + +#define ML99_CHAR_LIT(x) ML99_PRIV_CAT(ML99_PRIV_CHAR_LIT_, x) + +#ifndef DOXYGEN_IGNORE + +#define ML99_detectIdent_IMPL(prefix, ident) v(ML99_DETECT_IDENT(prefix, ident)) +#define ML99_identEq_IMPL(prefix, x, y) v(ML99_IDENT_EQ(prefix, x, y)) +#define ML99_charEq_IMPL(x, y) v(ML99_CHAR_EQ(x, y)) +#define ML99_isLowercase_IMPL(x) v(ML99_IS_LOWERCASE(x)) +#define ML99_isUppercase_IMPL(x) v(ML99_IS_UPPERCASE(x)) +#define ML99_isDigit_IMPL(x) v(ML99_IS_DIGIT(x)) +#define ML99_isChar_IMPL(x) v(ML99_IS_CHAR(x)) +#define ML99_charLit_IMPL(x) v(ML99_CHAR_LIT(x)) + +#define ML99_UNDERSCORE_DETECTOR ML99_PRIV_UNDERSCORE_DETECTOR_ +#define ML99_C_KEYWORD_DETECTOR ML99_PRIV_C_KEYWORD_DETECTOR_ +#define ML99_LOWERCASE_DETECTOR ML99_PRIV_LOWER_DETECTOR_ +#define ML99_UPPERCASE_DETECTOR ML99_PRIV_UPPER_DETECTOR_ +#define ML99_DIGIT_DETECTOR ML99_PRIV_DIGIT_DETECTOR_ + +#define ML99_PRIV_C_KEYWORD_DETECTOR_auto_auto () +#define ML99_PRIV_C_KEYWORD_DETECTOR_break_break () +#define ML99_PRIV_C_KEYWORD_DETECTOR_case_case () +#define ML99_PRIV_C_KEYWORD_DETECTOR_char_char () +#define ML99_PRIV_C_KEYWORD_DETECTOR_const_const () +#define ML99_PRIV_C_KEYWORD_DETECTOR_continue_continue () +#define ML99_PRIV_C_KEYWORD_DETECTOR_default_default () +#define ML99_PRIV_C_KEYWORD_DETECTOR_do_do () +#define ML99_PRIV_C_KEYWORD_DETECTOR_double_double () +#define ML99_PRIV_C_KEYWORD_DETECTOR_else_else () +#define ML99_PRIV_C_KEYWORD_DETECTOR_enum_enum () +#define ML99_PRIV_C_KEYWORD_DETECTOR_extern_extern () +#define ML99_PRIV_C_KEYWORD_DETECTOR_float_float () +#define ML99_PRIV_C_KEYWORD_DETECTOR_for_for () +#define ML99_PRIV_C_KEYWORD_DETECTOR_goto_goto () +#define ML99_PRIV_C_KEYWORD_DETECTOR_if_if () +#define ML99_PRIV_C_KEYWORD_DETECTOR_inline_inline () +#define ML99_PRIV_C_KEYWORD_DETECTOR_int_int () +#define ML99_PRIV_C_KEYWORD_DETECTOR_long_long () +#define ML99_PRIV_C_KEYWORD_DETECTOR_register_register () +#define ML99_PRIV_C_KEYWORD_DETECTOR_restrict_restrict () +#define ML99_PRIV_C_KEYWORD_DETECTOR_return_return () +#define ML99_PRIV_C_KEYWORD_DETECTOR_short_short () +#define ML99_PRIV_C_KEYWORD_DETECTOR_signed_signed () +#define ML99_PRIV_C_KEYWORD_DETECTOR_sizeof_sizeof () +#define ML99_PRIV_C_KEYWORD_DETECTOR_static_static () +#define ML99_PRIV_C_KEYWORD_DETECTOR_struct_struct () +#define ML99_PRIV_C_KEYWORD_DETECTOR_switch_switch () +#define ML99_PRIV_C_KEYWORD_DETECTOR_typedef_typedef () +#define ML99_PRIV_C_KEYWORD_DETECTOR_union_union () +#define ML99_PRIV_C_KEYWORD_DETECTOR_unsigned_unsigned () +#define ML99_PRIV_C_KEYWORD_DETECTOR_void_void () +#define ML99_PRIV_C_KEYWORD_DETECTOR_volatile_volatile () +#define ML99_PRIV_C_KEYWORD_DETECTOR_while_while () +#define ML99_PRIV_C_KEYWORD_DETECTOR__Alignas__Alignas () +#define ML99_PRIV_C_KEYWORD_DETECTOR__Alignof__Alignof () +#define ML99_PRIV_C_KEYWORD_DETECTOR__Atomic__Atomic () +#define ML99_PRIV_C_KEYWORD_DETECTOR__Bool__Bool () +#define ML99_PRIV_C_KEYWORD_DETECTOR__Complex__Complex () +#define ML99_PRIV_C_KEYWORD_DETECTOR__Generic__Generic () +#define ML99_PRIV_C_KEYWORD_DETECTOR__Imaginary__Imaginary () +#define ML99_PRIV_C_KEYWORD_DETECTOR__Noreturn__Noreturn () +#define ML99_PRIV_C_KEYWORD_DETECTOR__Static_assert__Static_assert () +#define ML99_PRIV_C_KEYWORD_DETECTOR__Thread_local__Thread_local () + +#define ML99_PRIV_UNDERSCORE_DETECTOR__ () + +#define ML99_PRIV_LOWER_DETECTOR_a_a () +#define ML99_PRIV_LOWER_DETECTOR_b_b () +#define ML99_PRIV_LOWER_DETECTOR_c_c () +#define ML99_PRIV_LOWER_DETECTOR_d_d () +#define ML99_PRIV_LOWER_DETECTOR_e_e () +#define ML99_PRIV_LOWER_DETECTOR_f_f () +#define ML99_PRIV_LOWER_DETECTOR_g_g () +#define ML99_PRIV_LOWER_DETECTOR_h_h () +#define ML99_PRIV_LOWER_DETECTOR_i_i () +#define ML99_PRIV_LOWER_DETECTOR_j_j () +#define ML99_PRIV_LOWER_DETECTOR_k_k () +#define ML99_PRIV_LOWER_DETECTOR_l_l () +#define ML99_PRIV_LOWER_DETECTOR_m_m () +#define ML99_PRIV_LOWER_DETECTOR_n_n () +#define ML99_PRIV_LOWER_DETECTOR_o_o () +#define ML99_PRIV_LOWER_DETECTOR_p_p () +#define ML99_PRIV_LOWER_DETECTOR_q_q () +#define ML99_PRIV_LOWER_DETECTOR_r_r () +#define ML99_PRIV_LOWER_DETECTOR_s_s () +#define ML99_PRIV_LOWER_DETECTOR_t_t () +#define ML99_PRIV_LOWER_DETECTOR_u_u () +#define ML99_PRIV_LOWER_DETECTOR_v_v () +#define ML99_PRIV_LOWER_DETECTOR_w_w () +#define ML99_PRIV_LOWER_DETECTOR_x_x () +#define ML99_PRIV_LOWER_DETECTOR_y_y () +#define ML99_PRIV_LOWER_DETECTOR_z_z () + +#define ML99_PRIV_UPPER_DETECTOR_A_A () +#define ML99_PRIV_UPPER_DETECTOR_B_B () +#define ML99_PRIV_UPPER_DETECTOR_C_C () +#define ML99_PRIV_UPPER_DETECTOR_D_D () +#define ML99_PRIV_UPPER_DETECTOR_E_E () +#define ML99_PRIV_UPPER_DETECTOR_F_F () +#define ML99_PRIV_UPPER_DETECTOR_G_G () +#define ML99_PRIV_UPPER_DETECTOR_H_H () +#define ML99_PRIV_UPPER_DETECTOR_I_I () +#define ML99_PRIV_UPPER_DETECTOR_J_J () +#define ML99_PRIV_UPPER_DETECTOR_K_K () +#define ML99_PRIV_UPPER_DETECTOR_L_L () +#define ML99_PRIV_UPPER_DETECTOR_M_M () +#define ML99_PRIV_UPPER_DETECTOR_N_N () +#define ML99_PRIV_UPPER_DETECTOR_O_O () +#define ML99_PRIV_UPPER_DETECTOR_P_P () +#define ML99_PRIV_UPPER_DETECTOR_Q_Q () +#define ML99_PRIV_UPPER_DETECTOR_R_R () +#define ML99_PRIV_UPPER_DETECTOR_S_S () +#define ML99_PRIV_UPPER_DETECTOR_T_T () +#define ML99_PRIV_UPPER_DETECTOR_U_U () +#define ML99_PRIV_UPPER_DETECTOR_V_V () +#define ML99_PRIV_UPPER_DETECTOR_W_W () +#define ML99_PRIV_UPPER_DETECTOR_X_X () +#define ML99_PRIV_UPPER_DETECTOR_Y_Y () +#define ML99_PRIV_UPPER_DETECTOR_Z_Z () + +#define ML99_PRIV_DIGIT_DETECTOR_0_0 () +#define ML99_PRIV_DIGIT_DETECTOR_1_1 () +#define ML99_PRIV_DIGIT_DETECTOR_2_2 () +#define ML99_PRIV_DIGIT_DETECTOR_3_3 () +#define ML99_PRIV_DIGIT_DETECTOR_4_4 () +#define ML99_PRIV_DIGIT_DETECTOR_5_5 () +#define ML99_PRIV_DIGIT_DETECTOR_6_6 () +#define ML99_PRIV_DIGIT_DETECTOR_7_7 () +#define ML99_PRIV_DIGIT_DETECTOR_8_8 () +#define ML99_PRIV_DIGIT_DETECTOR_9_9 () + +#define ML99_PRIV_CHAR_LIT_a 'a' +#define ML99_PRIV_CHAR_LIT_b 'b' +#define ML99_PRIV_CHAR_LIT_c 'c' +#define ML99_PRIV_CHAR_LIT_d 'd' +#define ML99_PRIV_CHAR_LIT_e 'e' +#define ML99_PRIV_CHAR_LIT_f 'f' +#define ML99_PRIV_CHAR_LIT_g 'g' +#define ML99_PRIV_CHAR_LIT_h 'h' +#define ML99_PRIV_CHAR_LIT_i 'i' +#define ML99_PRIV_CHAR_LIT_j 'j' +#define ML99_PRIV_CHAR_LIT_k 'k' +#define ML99_PRIV_CHAR_LIT_l 'l' +#define ML99_PRIV_CHAR_LIT_m 'm' +#define ML99_PRIV_CHAR_LIT_n 'n' +#define ML99_PRIV_CHAR_LIT_o 'o' +#define ML99_PRIV_CHAR_LIT_p 'p' +#define ML99_PRIV_CHAR_LIT_q 'q' +#define ML99_PRIV_CHAR_LIT_r 'r' +#define ML99_PRIV_CHAR_LIT_s 's' +#define ML99_PRIV_CHAR_LIT_t 't' +#define ML99_PRIV_CHAR_LIT_u 'u' +#define ML99_PRIV_CHAR_LIT_v 'v' +#define ML99_PRIV_CHAR_LIT_w 'w' +#define ML99_PRIV_CHAR_LIT_x 'x' +#define ML99_PRIV_CHAR_LIT_y 'y' +#define ML99_PRIV_CHAR_LIT_z 'z' + +#define ML99_PRIV_CHAR_LIT_A 'A' +#define ML99_PRIV_CHAR_LIT_B 'B' +#define ML99_PRIV_CHAR_LIT_C 'C' +#define ML99_PRIV_CHAR_LIT_D 'D' +#define ML99_PRIV_CHAR_LIT_E 'E' +#define ML99_PRIV_CHAR_LIT_F 'F' +#define ML99_PRIV_CHAR_LIT_G 'G' +#define ML99_PRIV_CHAR_LIT_H 'H' +#define ML99_PRIV_CHAR_LIT_I 'I' +#define ML99_PRIV_CHAR_LIT_J 'J' +#define ML99_PRIV_CHAR_LIT_K 'K' +#define ML99_PRIV_CHAR_LIT_L 'L' +#define ML99_PRIV_CHAR_LIT_M 'M' +#define ML99_PRIV_CHAR_LIT_N 'N' +#define ML99_PRIV_CHAR_LIT_O 'O' +#define ML99_PRIV_CHAR_LIT_P 'P' +#define ML99_PRIV_CHAR_LIT_Q 'Q' +#define ML99_PRIV_CHAR_LIT_R 'R' +#define ML99_PRIV_CHAR_LIT_S 'S' +#define ML99_PRIV_CHAR_LIT_T 'T' +#define ML99_PRIV_CHAR_LIT_U 'U' +#define ML99_PRIV_CHAR_LIT_V 'V' +#define ML99_PRIV_CHAR_LIT_W 'W' +#define ML99_PRIV_CHAR_LIT_X 'X' +#define ML99_PRIV_CHAR_LIT_Y 'Y' +#define ML99_PRIV_CHAR_LIT_Z 'Z' + +#define ML99_PRIV_CHAR_LIT_0 '0' +#define ML99_PRIV_CHAR_LIT_1 '1' +#define ML99_PRIV_CHAR_LIT_2 '2' +#define ML99_PRIV_CHAR_LIT_3 '3' +#define ML99_PRIV_CHAR_LIT_4 '4' +#define ML99_PRIV_CHAR_LIT_5 '5' +#define ML99_PRIV_CHAR_LIT_6 '6' +#define ML99_PRIV_CHAR_LIT_7 '7' +#define ML99_PRIV_CHAR_LIT_8 '8' +#define ML99_PRIV_CHAR_LIT_9 '9' + +#define ML99_PRIV_CHAR_LIT__ '_' + +// Arity specifiers { + +#define ML99_detectIdent_ARITY 2 +#define ML99_identEq_ARITY 3 +#define ML99_charEq_ARITY 2 +#define ML99_isLowercase_ARITY 1 +#define ML99_isUppercase_ARITY 1 +#define ML99_isDigit_ARITY 1 +#define ML99_isChar_ARITY 1 +#define ML99_charLit_ARITY 1 +// } (Arity specifiers) + +#endif // DOXYGEN_IGNORE + +#endif // ML99_IDENT_H diff --git a/test/external/metalang99/include/metalang99/lang.h b/test/external/metalang99/include/metalang99/lang.h new file mode 100644 index 0000000..299f8d7 --- /dev/null +++ b/test/external/metalang99/include/metalang99/lang.h @@ -0,0 +1,246 @@ +/** + * @file + * The core metalanguage. + */ + +#ifndef ML99_LANG_H +#define ML99_LANG_H + +#include <metalang99/priv/bool.h> +#include <metalang99/priv/tuple.h> + +#include <metalang99/eval/eval.h> +#include <metalang99/lang/closure.h> + +/** + * Evaluates a metaprogram. + * + * # Examples + * + * @code + * #include <metalang99/lang.h> + * + * #define F_IMPL(x, y) v(x + y) + * + * ML99_EVAL(v(abc ~ 123), ML99_call(F, v(1, 2))) + * @endcode + */ +#define ML99_EVAL(...) ML99_PRIV_EVAL(__VA_ARGS__) + +/** + * Invokes a metafunction with arguments. + */ +#define ML99_call(op, ...) \ + (ML99_PRIV_IF(ML99_PRIV_IS_UNTUPLE_FAST(op), 0args, 0op), op, __VA_ARGS__) + +/** + * Invokes a metafunction @p ident with unevaluated arguments. + * + * It is semantically the same as `ML99_call(ident, v(...))` but performs one less reduction + * steps. + */ +#define ML99_callUneval(ident, ...) (0callUneval, ident, __VA_ARGS__) + +/** + * Applies arguments to @p f. + * + * This function implements [partial + * application](https://en.wikipedia.org/wiki/Partial_application): instead of invoking a + * metafunction with all arguments at once, you specify each argument separately. This concept + * allows better re-use of metafunctions by specifying some arguments immediately, and the other + * arguments later, even in different execution contexts (for example, see this [SO + * answer](https://stackoverflow.com/a/12414292/13166656)). + * + * @p f must be either a term reducing to a macro name or a term obtained via another call to + * #ML99_appl. If @p f is a macro name, then a macro named `<f>_ARITY` (its arity specifier) + * must denote how many times @p f will be applied to its arguments. (In Metalang99, an arity is an + * intentionally more flexible concept than just a number of parameters, see below.) Each time + * #ML99_appl is invoked, it accumulates provided variadic arguments and decrements the arity + * of @p f; when the arity of @p f is already 1, it eventually calls the initial @p f with all the + * accumulated arguments and provided variadic arguments. + * + * Most often, an arity specifier denotes a count of all named parameters plus 1 if a macro is + * variadic (all the functions in the standard library follow this pattern). However, feel free to + * specify arities as you wish, with regard to the aforementioned semantics; for example, you can + * have a macro accepting `x, y, z` with an arity specifier `2`, then you must invoke + * #ML99_appl exactly 2 times (either `x` + `y, z` or `x, y` + `z`). One common pattern is to + * match a head and a tail of variadic arguments: + * + * @code + * #include <metalang99/lang.h> + * + * #define F_IMPL(x, y, z, head, ...) // ... + * #define F_ARITY 4 + * @endcode + * + * In this case, `x`, `y`, and `z` can be specified separately but other arguments all at once. + * + * # Examples + * + * @code + * #include <metalang99/lang.h> + * + * #define F_IMPL(x, y) v(x##y) + * #define F_ARITY 2 + * + * // ab + * ML99_appl(ML99_appl(v(F), v(a)), v(b)) + * @endcode + * + * @note Currently, the maximum arity is #ML99_NAT_MAX. However, some compilers might not support + * more than 127 macro parameters. + */ +#define ML99_appl(f, ...) ML99_call(ML99_appl, f, __VA_ARGS__) + +/** + * Applies @p a and @p b to @p f. + * + * # Examples + * + * @code + * #include <metalang99/lang.h> + * + * #define F_IMPL(x, y) v(x##y) + * #define F_ARITY 2 + * + * // ab + * ML99_appl2(v(F), v(a), v(b)) + * @endcode + */ +#define ML99_appl2(f, a, b) ML99_call(ML99_appl2, f, a, b) + +/** + * Applies @p a, @p b, and @p c to @p f. + */ +#define ML99_appl3(f, a, b, c) ML99_call(ML99_appl3, f, a, b, c) + +/** + * Applies @p a, @p b, @p c, and @p d to @p f. + */ +#define ML99_appl4(f, a, b, c, d) ML99_call(ML99_appl4, f, a, b, c, d) + +/** + * Functional composition of @p f and @p g. + * + * # Examples + * + * @code + * #include <metalang99/lang.h> + * + * #define F_IMPL(x) v((x + 1)) + * #define G_IMPL(x) v((x * 8)) + * + * #define F_ARITY 1 + * #define G_ARITY 1 + * + * // ((3 * 8) + 1) + * ML99_appl(ML99_compose(v(F), v(G)), v(3)) + * @endcode + */ +#define ML99_compose(f, g) ML99_call(ML99_compose, f, g) + +/** + * A value that is pasted as-is; no evaluation occurs on provided arguments. + */ +#define v(...) (0v, __VA_ARGS__) + +// clang-format off +/** + * Emits a fatal error. + * + * @p f must be a macro name that has caused the error and the rest of arguments comprise the error + * message. + * + * #ML99_fatal interprets its variadic arguments without preprocessor expansion -- i.e., they are + * pasted as-is. This is intended because otherwise identifiers located in an error message may + * stand for other macros that will be unintentionally expanded. + * + * # Examples + * + * [`playground.c`] + * @code + * #include <metalang99/lang.h> + * + * ML99_EVAL(ML99_fatal(F, the description of your error)) + * @endcode + * + * [`/bin/sh`] + * @code{.txt} + * playground.c:3:1: error: static assertion failed: "F: the description of your error" + * 3 | ML99_EVAL(ML99_fatal(F, the description of your error)) + * | ^~~~~~~~~ + * @endcode + */ +#define ML99_fatal(f, ...) (0fatal, f, #__VA_ARGS__) +// clang-format on + +/** + * Immediately aborts the interpretation with evaluated arguments. + * + * # Examples + * + * @code + * #include <metalang99/lang.h> + * + * #define F_IMPL(x) v(~) + * + * // 123 + * ML99_call(F, ML99_abort(v(123))) + * @endcode + */ +#define ML99_abort(...) (0abort, __VA_ARGS__) + +/** + * A convenience macro to emphasize that your metafunction expands to more than one term. + * + * This macro just expands to provided arguments. + * + * # Examples + * + * @code + * #include <metalang99/lang.h> + * + * #define F_IMPL(x) ML99_TERMS(v(1), v(x), v(2)) + * @endcode + */ +#define ML99_TERMS(...) __VA_ARGS__ + +/** + * Delays evaluation for provided terms. + * + * `ML99_QUOTE(...)` is functionally equivalent to `v(...)`. + * + * # Examples + * + * @code + * #include <metalang99/lang.h> + * + * #define F_IMPL(x) v(~x) + * + * #define PROG ML99_TERMS(v(1), v(2), ML99_call(F, v(7))) + * + * // The same as `PROG` pasted into a source file. + * ML99_EVAL(ML99_QUOTE(PROG)) + * @endcode + */ +#define ML99_QUOTE(...) v(__VA_ARGS__) + +#ifndef DOXYGEN_IGNORE + +#define ML99_compose_IMPL(f, g) ML99_appl2_IMPL(ML99_PRIV_compose, f, g) +#define ML99_PRIV_compose_IMPL(f, g, x) ML99_appl(v(f), ML99_appl_IMPL(g, x)) + +// Arity specifiers { + +#define ML99_appl_ARITY 2 +#define ML99_appl2_ARITY 3 +#define ML99_appl3_ARITY 4 +#define ML99_appl4_ARITY 5 +#define ML99_compose_ARITY 2 + +#define ML99_PRIV_compose_ARITY 3 +// } (Arity specifiers) + +#endif // DOXYGEN_IGNORE + +#endif // ML99_LANG_H diff --git a/test/external/metalang99/include/metalang99/lang/closure.h b/test/external/metalang99/include/metalang99/lang/closure.h new file mode 100644 index 0000000..3812df0 --- /dev/null +++ b/test/external/metalang99/include/metalang99/lang/closure.h @@ -0,0 +1,51 @@ +#ifndef ML99_LANG_CLOSURE_H +#define ML99_LANG_CLOSURE_H + +#include <metalang99/priv/bool.h> +#include <metalang99/priv/util.h> + +#include <metalang99/nat/dec.h> +#include <metalang99/nat/eq.h> + +/* + * A closure has the form `(arity, f, ...)`, where `arity` is how many times `ML99_appl` can + * be called for this closure, and `...` denotes the closure's environment. + * + * `ML99_appl` is described by the following algorithm: + * - If `f` is an identifier (like `FOO`): + * - If `f##_ARITY` is 1, then just call this function with provided arguments. + * - Otherwise, return `(f##_ARITY - 1, f, provided args...)`. + * - Otherwise (`f` is a closure): + * - If `arity` is 1, then just call `f` with its environment and provided arguments. + * - Otherwise, return `(arity - 1, f, env..., provided args...)`. + * + * Thus, each time except the last, `ML99_appl` extends a closure's environment with new + * arguments; the last time, it calls `f` with its environment. + */ + +#define ML99_appl_IMPL(f, ...) \ + ML99_PRIV_IF(ML99_PRIV_IS_UNTUPLE_FAST(f), ML99_PRIV_APPL_F, ML99_PRIV_APPL_CLOSURE) \ + (f, __VA_ARGS__) + +#define ML99_PRIV_APPL_F(f, ...) \ + ML99_PRIV_IF( \ + ML99_PRIV_NAT_EQ(f##_ARITY, 1), \ + ML99_callUneval(f, __VA_ARGS__), \ + v((ML99_PRIV_DEC(f##_ARITY), f, __VA_ARGS__))) + +#define ML99_PRIV_APPL_CLOSURE(closure, ...) \ + ML99_PRIV_APPL_CLOSURE_AUX(ML99_PRIV_EXPAND closure, __VA_ARGS__) + +#define ML99_PRIV_APPL_CLOSURE_AUX(...) ML99_PRIV_APPL_CLOSURE_AUX_AUX(__VA_ARGS__) + +#define ML99_PRIV_APPL_CLOSURE_AUX_AUX(arity, f, ...) \ + ML99_PRIV_IF( \ + ML99_PRIV_NAT_EQ(arity, 1), \ + ML99_callUneval(f, __VA_ARGS__), \ + v((ML99_PRIV_DEC(arity), f, __VA_ARGS__))) + +#define ML99_appl2_IMPL(f, a, b) ML99_appl(ML99_appl_IMPL(f, a), v(b)) +#define ML99_appl3_IMPL(f, a, b, c) ML99_appl(ML99_appl2_IMPL(f, a, b), v(c)) +#define ML99_appl4_IMPL(f, a, b, c, d) ML99_appl(ML99_appl3_IMPL(f, a, b, c), v(d)) + +#endif // ML99_LANG_CLOSURE_H diff --git a/test/external/metalang99/include/metalang99/list.h b/test/external/metalang99/include/metalang99/list.h new file mode 100644 index 0000000..bf62916 --- /dev/null +++ b/test/external/metalang99/include/metalang99/list.h @@ -0,0 +1,1129 @@ +/** + * @file + * Cons-lists. + */ + +#ifndef ML99_LIST_H +#define ML99_LIST_H + +#include <metalang99/priv/bool.h> +#include <metalang99/priv/util.h> + +#include <metalang99/bool.h> +#include <metalang99/choice.h> +#include <metalang99/nat.h> +#include <metalang99/seq.h> +#include <metalang99/util.h> +#include <metalang99/variadics.h> + +/** + * Prepends @p x to @p xs. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * ML99_cons(v(1), ML99_cons(v(2), ML99_nil())) + * @endcode + */ +#define ML99_cons(x, xs) ML99_call(ML99_cons, x, xs) + +/** + * The empty list. + */ +#define ML99_nil(...) ML99_callUneval(ML99_nil, ) + +/** + * Checks @p list for non-emptiness. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 1 + * ML99_isCons(ML99_list(v(1, 2, 3))) + * + * // 0 + * ML99_isCons(ML99_nil()) + * @endcode + */ +#define ML99_isCons(list) ML99_call(ML99_isCons, list) + +/** + * Checks @p list for emptiness. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 0 + * ML99_isNil(ML99_list(v(1, 2, 3))) + * + * // 1 + * ML99_isNil(ML99_nil()) + * @endcode + */ +#define ML99_isNil(list) ML99_call(ML99_isNil, list) + +/** + * Extracts the head from the non-empty list @p list. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 1 + * ML99_listHead(ML99_list(v(1, 2, 3))) + * @endcode + */ +#define ML99_listHead(list) ML99_call(ML99_listHead, list) + +/** + * Extracts the tail from the non-empty list @p list. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 2, 3 + * ML99_listTail(ML99_list(v(1, 2, 3))) + * + * // ML99_nil() + * ML99_listTail(ML99_list(v(1))) + * @endcode + */ +#define ML99_listTail(list) ML99_call(ML99_listTail, list) + +/** + * Extracts the last element from the non-empty list @p list. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 3 + * ML99_listLast(ML99_list(v(1, 2, 3))) + * @endcode + */ +#define ML99_listLast(list) ML99_call(ML99_listLast, list) + +/** + * Extracts all the elements of the non-empty list @p list except the last one. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 1, 2 + * ML99_listInit(ML99_list(v(1, 2, 3))) + * + * // ML99_nil() + * ML99_listInit(ML99_list(v(1))) + * @endcode + */ +#define ML99_listInit(list) ML99_call(ML99_listInit, list) + +/** + * Constructs a list from its arguments. + * + * At most 63 arguments are acceptable. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 1, 2, 3 + * ML99_list(v(1, 2, 3)) + * @endcode + */ +#define ML99_list(...) ML99_call(ML99_list, __VA_ARGS__) + +/** + * Constructs a list from comma-separated [tuples](tuple.html). + * + * It sequentially applies @p f to each untupled argument, thus forming the resulting list. If some + * argument is not a tuple, a fatal error is emitted. + * + * The result is `ML99_list(ML99_appl(f, ML99_untuple(x1)), ..., ML99_appl(f, ML99_untuple(xN)))`. + * + * Each variadic argument inherits all the preconditions of #ML99_isUntuple. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * #define F_IMPL(x, y) v(x + y) + * #define F_ARITY 1 + * + * // ML99_list(v(1 + 2, 3 + 4, 5 + 6)) + * ML99_listFromTuples(v(F), v((1, 2), (3, 4), (5, 6))) + * @endcode + */ +#define ML99_listFromTuples(f, ...) ML99_call(ML99_listFromTuples, f, __VA_ARGS__) + +/** + * Constructs a list from the [sequence](seq.html) @p seq. + * + * Note that @p seq items must **not** contain commas. If you want commas in items, such as `(+, -, + * *, /)`, consider wrapping an item in parentheses: `((+, -, *, /))`. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // ML99_nil() + * ML99_listFromSeq(v()) + * + * // ML99_list(v(1, 2, 3)) + * ML99_listFromSeq(v((1)(2)(3))) + * @endcode + */ +#define ML99_listFromSeq(seq) ML99_call(ML99_listFromSeq, seq) + +/** + * Computes the length of @p list. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 0 + * ML99_listLen(ML99_nil()) + * + * // 3 + * ML99_listLen(ML99_list(v(1, 2, 3))) + * @endcode + */ +#define ML99_listLen(list) ML99_call(ML99_listLen, list) + +/** + * Evaluates a metaprogram that reduces to a list, then unwraps it. + * + * It behaves the same as the composition of #ML99_EVAL and #ML99_listUnwrap. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // Literally 1 2 3 + * ML99_LIST_EVAL(ML99_list(v(1, 2, 3))) + * @endcode + * + * @note This macro does not result in a Metalang99 term; it literally pastes list elements into a + * source file. + */ +#define ML99_LIST_EVAL(...) ML99_EVAL(ML99_call(ML99_listUnwrap, __VA_ARGS__)) + +/** + * The same as #ML99_LIST_EVAL but intersperses a comma between list items. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * // Literally 1, 2, 3 + * ML99_LIST_EVAL_COMMA_SEP(ML99_list(v(1, 2, 3))) + * @endcode + * + * @note This macro does not result in a Metalang99 term; it literally pastes comma-separated list + * elements into a source file. + */ +#define ML99_LIST_EVAL_COMMA_SEP(...) ML99_EVAL(ML99_call(ML99_listUnwrapCommaSep, __VA_ARGS__)) + +/** + * Appends the list @p other to @p list. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 1, 2, 3 + * ML99_listAppend(ML99_list(v(1)), ML99_list(v(2, 3))) + * @endcode + */ +#define ML99_listAppend(list, other) ML99_call(ML99_listAppend, list, other) + +/** + * Appends the item @p item to @p list. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 1, 2, 3 + * ML99_listAppendItem(v(3), ML99_list(v(1, 2))) + * @endcode + */ +#define ML99_listAppendItem(item, list) ML99_call(ML99_listAppendItem, item, list) + +/** + * Places all the items in @p list as-is. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // Literally 1 2 3 + * ML99_listUnwrap(ML99_list(v(1, 2, 3))) + * @endcode + * + * @note The resulting value is still a valid Metalang99 term that need to be evaluated further. + * @see #ML99_LIST_EVAL + * @see #ML99_LIST_EVAL_COMMA_SEP + */ +#define ML99_listUnwrap(list) ML99_call(ML99_listUnwrap, list) + +/** + * Places all the items in @p list as-is, separated by commas. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // Literally 1, 2, 3 + * ML99_listUnwrapCommaSep(ML99_list(v(1, 2, 3))) + * @endcode + * + * @note The resulting value is still a valid Metalang99 term that need to be evaluated further. + * @see #ML99_LIST_EVAL + * @see #ML99_LIST_EVAL_COMMA_SEP + */ +#define ML99_listUnwrapCommaSep(list) ML99_call(ML99_listUnwrapCommaSep, list) + +/** + * Reverses the order of items in @p list. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 3, 2, 1 + * ML99_listReverse(ML99_list(v(1, 2, 3))) + * @endcode + */ +#define ML99_listReverse(list) ML99_call(ML99_listReverse, list) + +/** + * Extracts the @p i -indexed element. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 2 + * ML99_listGet(v(1), ML99_list(v(1, 2, 3))) + * @endcode + */ +#define ML99_listGet(i, list) ML99_call(ML99_listGet, i, list) + +/** + * A right-associative fold over @p list. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * #define ABCDEFG 123 + * + * // 7 + * ML99_listFoldr(v(ML99_cat), v(7), ML99_nil()) + * + * // 123 + * ML99_listFoldr(ML99_appl(v(ML99_flip), v(ML99_cat)), v(A), ML99_list(v(G, DEF, BC))) + * @endcode + */ +#define ML99_listFoldr(f, init, list) ML99_call(ML99_listFoldr, f, init, list) + +/** + * A left-associative fold over @p list. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * #define ABCDEFG 123 + * + * // 7 + * ML99_listFoldl(v(ML99_cat), v(7), ML99_nil()) + * + * // 123 + * ML99_listFoldl(v(ML99_cat), v(A), ML99_list(v(BC, DEF, G))) + * @endcode + */ +#define ML99_listFoldl(f, init, list) ML99_call(ML99_listFoldl, f, init, list) + +/** + * The same as #ML99_listFoldl but treats the first element of @p list as the initial value. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * #define ABCDEFG 123 + * + * // 123 + * ML99_listFoldl1(v(ML99_cat), ML99_list(v(AB, CDEF, G))) + * @endcode + */ +#define ML99_listFoldl1(f, list) ML99_call(ML99_listFoldl1, f, list) + +/** + * Intersperses @p item between the items in @p list. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 1, +, 2, +, 3 + * ML99_listIntersperse(v(+), ML99_list(v(1, 2, 3))) + * @endcode + */ +#define ML99_listIntersperse(item, list) ML99_call(ML99_listIntersperse, item, list) + +/** + * Prepends @p item to all items in @p list. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // +, 1, +, 2, +, 3 + * ML99_listPrependToAll(v(+), ML99_list(v(1, 2, 3))) + * @endcode + */ +#define ML99_listPrependToAll(item, list) ML99_call(ML99_listPrependToAll, item, list) + +/** + * Maps all the elements in @p list with @p f. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * #include <metalang99/nat.h> + * + * // 4, 5, 6 + * ML99_listMap(ML99_appl(v(ML99_add), v(3)), ML99_list(v(1, 2, 3))) + * @endcode + */ +#define ML99_listMap(f, list) ML99_call(ML99_listMap, f, list) + +/** + * The same as #ML99_listMap but provides an index of an element to @p f. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * #define F_IMPL(x, i) v(x[i]) + * #define F_ARITY 2 + * + * // a[0], b[1], c[2] + * ML99_listMapI(v(F), ML99_list(v(a, b, c))) + * @endcode + */ +#define ML99_listMapI(f, list) ML99_call(ML99_listMapI, f, list) + +/** + * A more efficient version of `ML99_listUnwrap(ML99_listMap(f, list))`. + * + * @note Unlike #ML99_listMap, @p f can evaluate to many terms. + */ +#define ML99_listMapInPlace(f, list) ML99_call(ML99_listMapInPlace, f, list) + +/** + * A more efficient version of `ML99_listUnwrap(ML99_listMapI(f, list))`. + * + * @note Unlike #ML99_listMapI, @p f can evaluate to many terms. + */ +#define ML99_listMapInPlaceI(f, list) ML99_call(ML99_listMapInPlaceI, f, list) + +/** + * The same as #ML99_listMap but with the reversed order of arguments. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * #include <metalang99/nat.h> + * + * // 4, 5, 6 + * ML99_listFor(ML99_list(v(1, 2, 3)), ML99_appl(v(ML99_add), v(3))) + * @endcode + */ +#define ML99_listFor(list, f) ML99_call(ML99_listFor, list, f) + +/** + * Maps the initial elements of the non-empty list @p list with @p f_init and the last element with + * @p f_last. + * + * # Examples + * + * @code + * // 4, 5, 10 + * ML99_listMapInitLast(ML99_appl(v(ML99_add), v(3)), ML99_appl(v(ML99_add), v(7)), ML99_list(v(1, + * 2, 3))) + * @endcode + */ +#define ML99_listMapInitLast(f_init, f_last, list) \ + ML99_call(ML99_listMapInitLast, f_init, f_last, list) + +/** + * The same as #ML99_listMapInitLast but accepts @p list as the first parameter. + * + * # Examples + * + * @code + * // 4, 5, 10 + * ML99_listForInitLast(ML99_list(v(1, 2, 3)), ML99_appl(v(ML99_add), v(3)), ML99_appl(v(ML99_add), + * v(7))) + * @endcode + */ +#define ML99_listForInitLast(list, f_init, f_last) \ + ML99_call(ML99_listForInitLast, list, f_init, f_last) + +/** + * Filters @p list with @p f. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * #include <metalang99/nat.h> + * + * // 9, 11, 6 + * ML99_listFilter(ML99_appl(v(ML99_lesser), v(5)), ML99_list(v(9, 1, 11, 6, 0, 4))) + * @endcode + */ +#define ML99_listFilter(f, list) ML99_call(ML99_listFilter, f, list) + +/** + * A combination of #ML99_listFilter and #ML99_listMap. + * + * It builds a new list by applying @p f to each element in @p list: if @p f yields `ML99_just(x)`, + * `x` is passed to the new list, otherwise (`ML99_nothing()`), the value is neglected. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * #include <metalang99/maybe.h> + * + * #define MAYBE_LIST ML99_list(ML99_just(v(5)), ML99_nothing(), ML99_just(v(7))) + * + * // 5, 7 + * ML99_listFilterMap(v(ML99_id), MAYBE_LIST) + * @endcode + */ +#define ML99_listFilterMap(f, list) ML99_call(ML99_listFilterMap, f, list) + +/** + * Tests @p list and @p other for equality. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * #include <metalang99/nat.h> + * + * // 0 + * ML99_listEq(v(ML99_natEq), ML99_list(v(1, 2, 3)), ML99_list(v(4, 5, 6))) + * + * // 1 + * ML99_listEq(v(ML99_natEq), ML99_list(v(1, 2, 3)), ML99_list(v(1, 2, 3))) + * @endcode + */ +#define ML99_listEq(cmp, list, other) ML99_call(ML99_listEq, cmp, list, other) + +/** + * Checks whether @p item resides in @p list. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * #include <metalang99/nat.h> + * + * // 1 + * ML99_listContains(v(ML99_natEq), v(3), ML99_list(v(1, 2, 3))) + * + * // 0 + * ML99_listContains(v(ML99_natEq), v(456), ML99_list(v(1, 2, 3))) + * @endcode + */ +#define ML99_listContains(cmp, item, list) ML99_call(ML99_listContains, cmp, item, list) + +/** + * Extracts the prefix of @p list of the length @p n. If @p n is greater than the length of @p list, + * the whole @p list is returned. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 1, 2 + * ML99_listTake(v(2), ML99_list(v(1, 2, 3))) + * @endcode + */ +#define ML99_listTake(n, list) ML99_call(ML99_listTake, n, list) + +/** + * Extracts the items from @p list as long as @p f evaluates to `ML99_true()`. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * #include <metalang99/nat.h> + * + * // 1, 2, 3 + * ML99_listTakeWhile(ML99_appl(v(ML99_greater), v(4)), ML99_list(v(1, 2, 3, 4, 5, 6))) + * @endcode + */ +#define ML99_listTakeWhile(f, list) ML99_call(ML99_listTakeWhile, f, list) + +/** + * Removes the prefix of @p list of the length @p n. If @p n is greater than the length of @p list, + * `ML99_nil()` is returned. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // 2, 3 + * ML99_listDrop(v(1), ML99_list(v(1, 2, 3))) + * @endcode + */ +#define ML99_listDrop(n, list) ML99_call(ML99_listDrop, n, list) + +/** + * Removes the items from @p list as long as @p f evaluates to `ML99_true()`. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * #include <metalang99/nat.h> + * + * // 4, 5, 6 + * ML99_listDropWhile(ML99_appl(v(ML99_lesser), v(4)), ML99_list(v(1, 2, 3, 4, 5, 6))) + * @endcode + */ +#define ML99_listDropWhile(f, list) ML99_call(ML99_listDropWhile, f, list) + +/** + * Computes a list of two-place tuples of the corresponding items from @p list and @p other. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // (1, 4), (2, 5), (3, 6) + * ML99_listZip(ML99_list(v(1, 2, 3)), ML99_list(v(4, 5, 6))) + * @endcode + */ +#define ML99_listZip(list, other) ML99_call(ML99_listZip, list, other) + +/** + * Transforms a list of two-place tuples into a tuple of a list of the first components and a list + * of the second components. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * #include <metalang99/tuple.h> + * + * // ML99_tuple(ML99_list(v(1, 2, 3)), ML99_list(v(4, 5, 6))) + * ML99_listUnzip(ML99_list(ML99_tuple(v(1, 4)), ML99_tuple(v(2, 5)), ML99_tuple(v(3, 6)))) + * @endcode + */ +#define ML99_listUnzip(list) ML99_call(ML99_listUnzip, list) + +/** + * Computes a list of length @p n with each element @p item. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * + * // ~, ~, ~, ~, ~ + * ML99_listReplicate(v(5), v(~)) + * + * // ML99_nil() + * ML99_listReplicate(v(0), v(~)) + * @endcode + */ +#define ML99_listReplicate(n, item) ML99_call(ML99_listReplicate, n, item) + +/** + * Returns a two-place tuple of lists: those items of @p list the do and do not satisfy the + * predicate @p f, respectively. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * #include <metalang99/nat.h> + * + * // ML99_tuple(ML99_list(v(4, 7)), ML99_list(v(11, 12, 13))) + * ML99_listPartition(ML99_appl(v(ML99_greater), v(10)), ML99_list(v(11, 4, 12, 13, 7))) + * @endcode + */ +#define ML99_listPartition(f, list) ML99_call(ML99_listPartition, f, list) + +/** + * Applies all the items in @p list to @p f. + * + * If the list is empty, results in @p f as-is. + * + * # Examples + * + * @code + * #include <metalang99/list.h> + * #include <metalang99/nat.h> + * + * // ML99_add + * ML99_listAppl(v(ML99_add), ML99_nil()) + * + * // ML99_appl(v(ML99_add), v(1)) + * ML99_listAppl(v(ML99_add), ML99_list(v(1))) + * + * // ML99_appl2(v(ML99_add), v(1), v(2)) + * ML99_listAppl(v(ML99_add), ML99_list(v(1, 2))) + * @endcode + */ +#define ML99_listAppl(f, list) ML99_call(ML99_listAppl, f, list) + +#define ML99_CONS(x, xs) ML99_CHOICE(cons, x, xs) +#define ML99_NIL(...) ML99_CHOICE(nil, ~) +#define ML99_IS_CONS(list) ML99_NOT(ML99_IS_NIL(list)) +#define ML99_IS_NIL(list) ML99_PRIV_IS_NIL(list) + +#ifndef DOXYGEN_IGNORE + +#define ML99_cons_IMPL(x, xs) v(ML99_CONS(x, xs)) +#define ML99_nil_IMPL(...) v(ML99_NIL()) + +#define ML99_isCons_IMPL(list) v(ML99_IS_CONS(list)) +#define ML99_isNil_IMPL(list) v(ML99_IS_NIL(list)) + +#define ML99_listHead_IMPL(list) ML99_match_IMPL(list, ML99_PRIV_listHead_) +#define ML99_PRIV_listHead_nil_IMPL(_) ML99_PRIV_EMPTY_LIST_ERROR(listHead) +#define ML99_PRIV_listHead_cons_IMPL(x, _xs) v(x) + +#define ML99_listTail_IMPL(list) ML99_match_IMPL(list, ML99_PRIV_listTail_) +#define ML99_PRIV_listTail_nil_IMPL(_) ML99_PRIV_EMPTY_LIST_ERROR(listTail) +#define ML99_PRIV_listTail_cons_IMPL(_x, xs) v(xs) + +#define ML99_listLast_IMPL(list) ML99_match_IMPL(list, ML99_PRIV_listLast_) +#define ML99_PRIV_listLast_nil_IMPL(_) ML99_PRIV_EMPTY_LIST_ERROR(listLast) +#define ML99_PRIV_listLast_cons_IMPL(x, xs) \ + ML99_PRIV_IF(ML99_IS_NIL(xs), v(x), ML99_listLast_IMPL(xs)) + +#define ML99_listInit_IMPL(list) ML99_match_IMPL(list, ML99_PRIV_listInit_) +#define ML99_PRIV_listInit_nil_IMPL(_) ML99_PRIV_EMPTY_LIST_ERROR(listInit) +#define ML99_PRIV_listInit_cons_IMPL(x, xs) \ + ML99_PRIV_IF(ML99_IS_NIL(xs), v(ML99_NIL()), ML99_cons(v(x), ML99_listInit_IMPL(xs))) + +// ML99_list_IMPL { + +#define ML99_list_IMPL(...) \ + ML99_PRIV_listProgress_IMPL(ML99_VARIADICS_COUNT(__VA_ARGS__), __VA_ARGS__, ~) + +// Last 4 recursion steps unrolled. +#define ML99_PRIV_listProgress_IMPL(count, ...) \ + ML99_PRIV_IF( \ + ML99_NAT_EQ(count, 4), \ + ML99_PRIV_listDone_4, \ + ML99_PRIV_IF( \ + ML99_NAT_EQ(count, 3), \ + ML99_PRIV_listDone_3, \ + ML99_PRIV_IF( \ + ML99_NAT_EQ(count, 2), \ + ML99_PRIV_listDone_2, \ + ML99_PRIV_IF( \ + ML99_NAT_EQ(count, 1), \ + ML99_PRIV_listDone_1, \ + ML99_PRIV_IF( \ + ML99_NAT_EQ(count, 0), \ + ML99_PRIV_listDone_0, \ + ML99_PRIV_listProgressAux))))) \ + (count, __VA_ARGS__) + +#define ML99_PRIV_listProgressAux(count, x, ...) \ + ML99_cons(v(x), ML99_callUneval(ML99_PRIV_listProgress, ML99_DEC(count), __VA_ARGS__)) + +#define ML99_PRIV_listDone_0(_count, _) v(ML99_NIL()) +#define ML99_PRIV_listDone_1(_count, a, _) v(ML99_CONS(a, ML99_NIL())) +#define ML99_PRIV_listDone_2(_count, a, b, _) v(ML99_CONS(a, ML99_CONS(b, ML99_NIL()))) +#define ML99_PRIV_listDone_3(_count, a, b, c, _) \ + v(ML99_CONS(a, ML99_CONS(b, ML99_CONS(c, ML99_NIL())))) +#define ML99_PRIV_listDone_4(_count, a, b, c, d, _) \ + v(ML99_CONS(a, ML99_CONS(b, ML99_CONS(c, ML99_CONS(d, ML99_NIL()))))) +// } (ML99_list_IMPL) + +// ML99_listFromTuples_IMPL { + +#define ML99_listFromTuples_IMPL(f, ...) ML99_PRIV_listFromTuplesAux_IMPL(f, __VA_ARGS__, ~) + +#define ML99_PRIV_listFromTuplesAux_IMPL(f, x, ...) \ + ML99_PRIV_CAT(ML99_PRIV_listFromTuples_, ML99_IS_UNTUPLE(x))(f, x, __VA_ARGS__) + +#define ML99_PRIV_listFromTuples_1(_f, x, ...) ML99_PRIV_NOT_TUPLE_ERROR(x) +#define ML99_PRIV_listFromTuples_0(f, x, ...) \ + ML99_cons( \ + ML99_appl_IMPL(f, ML99_UNTUPLE(x)), \ + ML99_PRIV_IF( \ + ML99_VARIADICS_IS_SINGLE(__VA_ARGS__), \ + v(ML99_NIL()), \ + ML99_callUneval(ML99_PRIV_listFromTuplesAux, f, __VA_ARGS__))) +// } (ML99_listFromTuples_IMPL) + +#define ML99_listFromSeq_IMPL(seq) \ + ML99_PRIV_CAT(ML99_PRIV_listFromSeq_, ML99_SEQ_IS_EMPTY(seq))(seq) +#define ML99_PRIV_listFromSeq_1 ML99_nil_IMPL +#define ML99_PRIV_listFromSeq_0(seq) \ + ML99_cons(v(ML99_SEQ_GET(0)(seq)), ML99_callUneval(ML99_listFromSeq, ML99_SEQ_TAIL(seq))) + +#define ML99_listLen_IMPL(list) ML99_match_IMPL(list, ML99_PRIV_listLen_) +#define ML99_PRIV_listLen_nil_IMPL(_) v(0) +#define ML99_PRIV_listLen_cons_IMPL(_x, xs) ML99_inc(ML99_listLen_IMPL(xs)) + +#define ML99_listAppend_IMPL(list, other) \ + ML99_matchWithArgs_IMPL(list, ML99_PRIV_listAppend_, other) +#define ML99_PRIV_listAppend_nil_IMPL(_, other) v(other) +#define ML99_PRIV_listAppend_cons_IMPL(x, xs, other) \ + ML99_cons(v(x), ML99_listAppend_IMPL(xs, other)) + +#define ML99_listAppendItem_IMPL(item, list) ML99_listAppend_IMPL(list, ML99_CONS(item, ML99_NIL())) + +#define ML99_listUnwrap_IMPL(list) ML99_match_IMPL(list, ML99_PRIV_listUnwrap_) +#define ML99_PRIV_listUnwrap_nil_IMPL ML99_empty_IMPL +#define ML99_PRIV_listUnwrap_cons_IMPL(x, xs) ML99_TERMS(v(x), ML99_listUnwrap_IMPL(xs)) + +#define ML99_listReverse_IMPL(list) ML99_match_IMPL(list, ML99_PRIV_listReverse_) +#define ML99_PRIV_listReverse_nil_IMPL ML99_nil_IMPL +#define ML99_PRIV_listReverse_cons_IMPL(x, xs) ML99_listAppendItem(v(x), ML99_listReverse_IMPL(xs)) + +#define ML99_listGet_IMPL(i, list) ML99_matchWithArgs_IMPL(list, ML99_PRIV_listGet_, i) +#define ML99_PRIV_listGet_nil_IMPL(_, i) ML99_PRIV_EMPTY_LIST_ERROR(ML99_listGet) +#define ML99_PRIV_listGet_cons_IMPL(x, xs, i) \ + ML99_PRIV_IF(ML99_NAT_EQ(i, 0), v(x), ML99_listGet_IMPL(ML99_DEC(i), xs)) + +#define ML99_listFoldr_IMPL(f, init, list) \ + ML99_matchWithArgs_IMPL(list, ML99_PRIV_listFoldr_, f, init) +#define ML99_PRIV_listFoldr_nil_IMPL(_, _f, acc) v(acc) +#define ML99_PRIV_listFoldr_cons_IMPL(x, xs, f, acc) \ + ML99_call(ML99_appl2, v(f, x), ML99_listFoldr_IMPL(f, acc, xs)) + +#define ML99_listFoldl_IMPL(f, init, list) \ + ML99_matchWithArgs_IMPL(list, ML99_PRIV_listFoldl_, f, init) +#define ML99_PRIV_listFoldl_nil_IMPL(_, _f, acc) v(acc) +#define ML99_PRIV_listFoldl_cons_IMPL(x, xs, f, acc) \ + ML99_listFoldl(v(f), ML99_appl2_IMPL(f, acc, x), v(xs)) + +#define ML99_listFoldl1_IMPL(f, list) ML99_matchWithArgs_IMPL(list, ML99_PRIV_listFoldl1_, f) +#define ML99_PRIV_listFoldl1_nil_IMPL(_, _f) ML99_PRIV_EMPTY_LIST_ERROR(ML99_listFoldl1) +#define ML99_PRIV_listFoldl1_cons_IMPL(x, xs, f) ML99_listFoldl_IMPL(f, x, xs) + +#define ML99_listIntersperse_IMPL(item, list) \ + ML99_matchWithArgs_IMPL(list, ML99_PRIV_listIntersperse_, item) +#define ML99_PRIV_listIntersperse_nil_IMPL ML99_nil_IMPL +#define ML99_PRIV_listIntersperse_cons_IMPL(x, xs, item) \ + ML99_cons(v(x), ML99_listPrependToAll_IMPL(item, xs)) + +#define ML99_listPrependToAll_IMPL(item, list) \ + ML99_matchWithArgs_IMPL(list, ML99_PRIV_listPrependToAll_, item) +#define ML99_PRIV_listPrependToAll_nil_IMPL ML99_nil_IMPL +#define ML99_PRIV_listPrependToAll_cons_IMPL(x, xs, item) \ + ML99_cons(v(item), ML99_cons(v(x), ML99_listPrependToAll_IMPL(item, xs))) + +#define ML99_listMap_IMPL(f, list) ML99_matchWithArgs_IMPL(list, ML99_PRIV_listMap_, f) +#define ML99_PRIV_listMap_nil_IMPL ML99_nil_IMPL +#define ML99_PRIV_listMap_cons_IMPL(x, xs, f) \ + ML99_cons(ML99_appl_IMPL(f, x), ML99_listMap_IMPL(f, xs)) + +#define ML99_listMapI_IMPL(f, list) ML99_PRIV_listMapIAux_IMPL(f, list, 0) +#define ML99_PRIV_listMapIAux_IMPL(f, list, i) \ + ML99_matchWithArgs_IMPL(list, ML99_PRIV_listMapI_, f, i) +#define ML99_PRIV_listMapI_nil_IMPL ML99_nil_IMPL +#define ML99_PRIV_listMapI_cons_IMPL(x, xs, f, i) \ + ML99_cons(ML99_appl2_IMPL(f, x, i), ML99_PRIV_listMapIAux_IMPL(f, xs, ML99_INC(i))) + +#define ML99_listMapInPlace_IMPL(f, list) \ + ML99_matchWithArgs_IMPL(list, ML99_PRIV_listMapInPlace_, f) +#define ML99_PRIV_listMapInPlace_nil_IMPL ML99_empty_IMPL +#define ML99_PRIV_listMapInPlace_cons_IMPL(x, xs, f) \ + ML99_TERMS(ML99_appl_IMPL(f, x), ML99_listMapInPlace_IMPL(f, xs)) + +#define ML99_listMapInPlaceI_IMPL(f, list) ML99_PRIV_listMapInPlaceIAux_IMPL(f, list, 0) +#define ML99_PRIV_listMapInPlaceIAux_IMPL(f, list, i) \ + ML99_matchWithArgs_IMPL(list, ML99_PRIV_listMapInPlaceI_, f, i) +#define ML99_PRIV_listMapInPlaceI_nil_IMPL ML99_empty_IMPL +#define ML99_PRIV_listMapInPlaceI_cons_IMPL(x, xs, f, i) \ + ML99_TERMS(ML99_appl2_IMPL(f, x, i), ML99_PRIV_listMapInPlaceIAux_IMPL(f, xs, ML99_INC(i))) + +#define ML99_listFor_IMPL(list, f) ML99_listMap_IMPL(f, list) + +#define ML99_listMapInitLast_IMPL(f_init, f_last, list) \ + ML99_listAppendItem( \ + ML99_appl(v(f_last), ML99_listLast_IMPL(list)), \ + ML99_listMap(v(f_init), ML99_listInit_IMPL(list))) + +#define ML99_listForInitLast_IMPL(list, f_init, f_last) \ + ML99_listMapInitLast_IMPL(f_init, f_last, list) + +// ML99_listFilter_IMPL { + +#define ML99_listFilter_IMPL(f, list) ML99_matchWithArgs_IMPL(list, ML99_PRIV_listFilter_, f) + +#define ML99_PRIV_listFilter_nil_IMPL ML99_nil_IMPL +#define ML99_PRIV_listFilter_cons_IMPL(x, xs, f) \ + ML99_call( \ + ML99_boolMatchWithArgs, \ + ML99_appl_IMPL(f, x), \ + v(ML99_PRIV_listFilter_cons_, x), \ + ML99_listFilter_IMPL(f, xs)) + +#define ML99_PRIV_listFilter_cons_1_IMPL(x, rest) v(ML99_CONS(x, rest)) +#define ML99_PRIV_listFilter_cons_0_IMPL(_x, rest) v(rest) +// } (ML99_listFilter_IMPL) + +// ML99_listFilterMap_IMPL { + +#define ML99_listFilterMap_IMPL(f, list) ML99_matchWithArgs_IMPL(list, ML99_PRIV_listFilterMap_, f) + +#define ML99_PRIV_listFilterMap_nil_IMPL ML99_nil_IMPL +#define ML99_PRIV_listFilterMap_cons_IMPL(x, xs, f) \ + ML99_call(ML99_matchWithArgs, ML99_appl_IMPL(f, x), v(ML99_PRIV_listFilterMap_cons_, f, xs)) + +#define ML99_PRIV_listFilterMap_cons_just_IMPL(y, f, xs) \ + ML99_cons(v(y), ML99_listFilterMap_IMPL(f, xs)) +#define ML99_PRIV_listFilterMap_cons_nothing_IMPL(_, f, xs) ML99_listFilterMap_IMPL(f, xs) +// } (ML99_listFilterMap_IMPL) + +// ML99_listEq_IMPL { + +#define ML99_listEq_IMPL(cmp, list, other) \ + ML99_matchWithArgs_IMPL(list, ML99_PRIV_listEq_, other, cmp) + +#define ML99_PRIV_listEq_nil_IMPL(_, other, _cmp) v(ML99_IS_NIL(other)) +#define ML99_PRIV_listEq_cons_IMPL(x, xs, other, cmp) \ + ML99_matchWithArgs_IMPL(other, ML99_PRIV_listEq_cons_, x, xs, cmp) + +#define ML99_PRIV_listEq_cons_nil_IMPL ML99_false_IMPL +#define ML99_PRIV_listEq_cons_cons_IMPL(other_x, other_xs, x, xs, cmp) \ + ML99_call( \ + ML99_call(ML99_if, ML99_appl2_IMPL(cmp, x, other_x), v(ML99_listEq, ML99_false)), \ + v(cmp, xs, other_xs)) +// } (ML99_listEq_IMPL) + +#define ML99_listContains_IMPL(cmp, item, list) \ + ML99_matchWithArgs_IMPL(list, ML99_PRIV_listContains_, item, cmp) +#define ML99_PRIV_listContains_nil_IMPL ML99_false_IMPL +#define ML99_PRIV_listContains_cons_IMPL(x, xs, item, cmp) \ + ML99_call( \ + ML99_call(ML99_if, ML99_appl2_IMPL(cmp, x, item), v(ML99_true, ML99_listContains)), \ + v(cmp, item, xs)) + +#define ML99_listTake_IMPL(n, list) ML99_matchWithArgs_IMPL(list, ML99_PRIV_listTake_, n) +#define ML99_PRIV_listTake_nil_IMPL ML99_nil_IMPL +#define ML99_PRIV_listTake_cons_IMPL(x, xs, i) \ + ML99_PRIV_IF( \ + ML99_NAT_EQ(i, 0), \ + v(ML99_NIL()), \ + ML99_cons(v(x), ML99_listTake_IMPL(ML99_DEC(i), xs))) + +// ML99_listTakeWhile_IMPL { + +#define ML99_listTakeWhile_IMPL(f, list) ML99_matchWithArgs_IMPL(list, ML99_PRIV_listTakeWhile_, f) + +#define ML99_PRIV_listTakeWhile_nil_IMPL ML99_nil_IMPL +#define ML99_PRIV_listTakeWhile_cons_IMPL(x, xs, f) \ + ML99_call( \ + ML99_boolMatchWithArgs, \ + ML99_appl_IMPL(f, x), \ + v(ML99_PRIV_listTakeWhile_cons_, x, xs, f)) + +#define ML99_PRIV_listTakeWhile_cons_1_IMPL(x, xs, f) \ + ML99_cons(v(x), ML99_listTakeWhile_IMPL(f, xs)) +#define ML99_PRIV_listTakeWhile_cons_0_IMPL ML99_nil_IMPL +// } (ML99_listTakeWhile_IMPL) + +#define ML99_listDrop_IMPL(n, list) ML99_matchWithArgs_IMPL(list, ML99_PRIV_listDrop_, n) +#define ML99_PRIV_listDrop_nil_IMPL ML99_nil_IMPL +#define ML99_PRIV_listDrop_cons_IMPL(x, xs, i) \ + ML99_PRIV_IF(ML99_NAT_EQ(i, 0), v(ML99_CONS(x, xs)), ML99_listDrop_IMPL(ML99_DEC(i), xs)) + +// ML99_listDropWhile_IMPL { + +#define ML99_listDropWhile_IMPL(f, list) ML99_matchWithArgs_IMPL(list, ML99_PRIV_listDropWhile_, f) + +#define ML99_PRIV_listDropWhile_nil_IMPL ML99_nil_IMPL +#define ML99_PRIV_listDropWhile_cons_IMPL(x, xs, f) \ + ML99_call( \ + ML99_boolMatchWithArgs, \ + ML99_appl_IMPL(f, x), \ + v(ML99_PRIV_listDropWhile_cons_, x, xs, f)) + +#define ML99_PRIV_listDropWhile_cons_0_IMPL(x, xs, _f) v(ML99_CONS(x, xs)) +#define ML99_PRIV_listDropWhile_cons_1_IMPL(_x, xs, f) ML99_listDropWhile_IMPL(f, xs) +// } (ML99_listDropWhile_IMPL) + +// ML99_listZip_IMPL { + +#define ML99_listZip_IMPL(list, other) ML99_matchWithArgs_IMPL(list, ML99_PRIV_listZip_, other) + +#define ML99_PRIV_listZip_nil_IMPL ML99_nil_IMPL +#define ML99_PRIV_listZip_cons_IMPL(x, xs, other) \ + ML99_matchWithArgs_IMPL(other, ML99_PRIV_listZip_cons_, x, xs) + +#define ML99_PRIV_listZip_cons_nil_IMPL ML99_nil_IMPL +#define ML99_PRIV_listZip_cons_cons_IMPL(other_x, other_xs, x, xs) \ + ML99_cons(v(ML99_TUPLE(x, other_x)), ML99_listZip_IMPL(xs, other_xs)) +// } (ML99_listZip_IMPL) + +// ML99_listUnzip_IMPL { + +#define ML99_listUnzip_IMPL(list) ML99_match_IMPL(list, ML99_PRIV_listUnzip_) + +#define ML99_PRIV_listUnzip_nil_IMPL(_) v(ML99_TUPLE(ML99_NIL(), ML99_NIL())) +#define ML99_PRIV_listUnzip_cons_IMPL(x, xs) \ + ML99_call(ML99_PRIV_listUnzipProgress, v(x), ML99_listUnzip_IMPL(xs)) + +#define ML99_PRIV_listUnzipProgress_IMPL(x, rest) \ + v(ML99_TUPLE(ML99_PRIV_LIST_UNZIP_EXTEND(x, rest, 0), ML99_PRIV_LIST_UNZIP_EXTEND(x, rest, 1))) + +#define ML99_PRIV_LIST_UNZIP_EXTEND(x, rest, i) \ + ML99_CONS(ML99_TUPLE_GET(i)(x), ML99_TUPLE_GET(i)(rest)) +// } (ML99_listUnzip_IMPL) + +#define ML99_listReplicate_IMPL(n, item) \ + ML99_natMatchWithArgs_IMPL(n, ML99_PRIV_listReplicate_, item) +#define ML99_PRIV_listReplicate_Z_IMPL ML99_nil_IMPL +#define ML99_PRIV_listReplicate_S_IMPL(n, item) ML99_cons(v(item), ML99_listReplicate_IMPL(n, item)) + +// ML99_listPartition_IMPL { + +#define ML99_listPartition_IMPL(f, list) \ + ML99_listFoldr( \ + ML99_appl_IMPL(ML99_PRIV_listPartitionAux, f), \ + v(ML99_TUPLE(ML99_NIL(), ML99_NIL())), \ + v(list)) + +#define ML99_PRIV_listPartitionAux_IMPL(f, x, acc) \ + ML99_call( \ + ML99_boolMatchWithArgs, \ + ML99_appl_IMPL(f, x), \ + v(ML99_PRIV_listPartition_, x, ML99_UNTUPLE(acc))) + +#define ML99_PRIV_listPartition_1_IMPL(x, fst, snd) v(ML99_TUPLE(ML99_CONS(x, fst), snd)) +#define ML99_PRIV_listPartition_0_IMPL(x, fst, snd) v(ML99_TUPLE(fst, ML99_CONS(x, snd))) +// } (ML99_listPartition_IMPL) + +#define ML99_listAppl_IMPL(f, list) ML99_listFoldl_IMPL(ML99_appl, f, list) + +// ML99_listUnwrapCommaSep_IMPL { + +#define ML99_listUnwrapCommaSep_IMPL(list) \ + ML99_PRIV_IF( \ + ML99_IS_NIL(list), \ + v(ML99_EMPTY()), \ + ML99_variadicsTail(ML99_PRIV_listUnwrapCommaSepAux_IMPL(list))) + +#define ML99_PRIV_listUnwrapCommaSepAux_IMPL(xs) ML99_match_IMPL(xs, ML99_PRIV_listUnwrapCommaSep_) + +#define ML99_PRIV_listUnwrapCommaSep_nil_IMPL ML99_empty_IMPL +#define ML99_PRIV_listUnwrapCommaSep_cons_IMPL(x, xs) \ + ML99_TERMS(v(, x), ML99_PRIV_listUnwrapCommaSepAux_IMPL(xs)) +// } (ML99_listUnwrapCommaSep_IMPL) + +// clang-format off +#define ML99_PRIV_EMPTY_LIST_ERROR(f) ML99_fatal(ML99_##f, expected a non-empty list) +// clang-format on + +#define ML99_PRIV_IS_NIL(list) ML99_DETECT_IDENT(ML99_PRIV_IS_NIL_, ML99_CHOICE_TAG(list)) +#define ML99_PRIV_IS_NIL_nil () + +// Arity specifiers { + +#define ML99_cons_ARITY 2 +#define ML99_nil_ARITY 1 +#define ML99_isCons_ARITY 1 +#define ML99_isNil_ARITY 1 +#define ML99_listHead_ARITY 1 +#define ML99_listTail_ARITY 1 +#define ML99_listLast_ARITY 1 +#define ML99_listInit_ARITY 1 +#define ML99_list_ARITY 1 +#define ML99_listFromTuples_ARITY 2 +#define ML99_listFromSeq_ARITY 1 +#define ML99_listLen_ARITY 1 +#define ML99_listAppend_ARITY 2 +#define ML99_listAppendItem_ARITY 2 +#define ML99_listUnwrap_ARITY 1 +#define ML99_listUnwrapCommaSep_ARITY 1 +#define ML99_listReverse_ARITY 1 +#define ML99_listGet_ARITY 2 +#define ML99_listFoldr_ARITY 3 +#define ML99_listFoldl_ARITY 3 +#define ML99_listFoldl1_ARITY 2 +#define ML99_listIntersperse_ARITY 2 +#define ML99_listPrependToAll_ARITY 2 +#define ML99_listMap_ARITY 2 +#define ML99_listMapI_ARITY 2 +#define ML99_listMapInPlace_ARITY 2 +#define ML99_listMapInPlaceI_ARITY 2 +#define ML99_listFor_ARITY 2 +#define ML99_listMapInitLast_ARITY 3 +#define ML99_listForInitLast_ARITY 3 +#define ML99_listFilter_ARITY 2 +#define ML99_listFilterMap_ARITY 2 +#define ML99_listEq_ARITY 3 +#define ML99_listContains_ARITY 3 +#define ML99_listTake_ARITY 2 +#define ML99_listTakeWhile_ARITY 2 +#define ML99_listDrop_ARITY 2 +#define ML99_listDropWhile_ARITY 2 +#define ML99_listZip_ARITY 2 +#define ML99_listUnzip_ARITY 1 +#define ML99_listReplicate_ARITY 2 +#define ML99_listPartition_ARITY 2 +#define ML99_listAppl_ARITY 2 + +#define ML99_PRIV_listPartitionAux_ARITY 3 +// } (Arity specifiers) + +#endif // DOXYGEN_IGNORE + +#endif // ML99_LIST_H diff --git a/test/external/metalang99/include/metalang99/logical.h b/test/external/metalang99/include/metalang99/logical.h new file mode 100644 index 0000000..9783944 --- /dev/null +++ b/test/external/metalang99/include/metalang99/logical.h @@ -0,0 +1,11 @@ +/** + * @file + * This module is deprecated and exists only for backwards compatibility. + */ + +#ifndef ML99_LOGICAL_H +#define ML99_LOGICAL_H + +#include <metalang99/bool.h> + +#endif // ML99_LOGICAL_H diff --git a/test/external/metalang99/include/metalang99/maybe.h b/test/external/metalang99/include/metalang99/maybe.h new file mode 100644 index 0000000..b51c4d2 --- /dev/null +++ b/test/external/metalang99/include/metalang99/maybe.h @@ -0,0 +1,143 @@ +/** + * @file + * An optional value. + */ + +#ifndef ML99_MAYBE_H +#define ML99_MAYBE_H + +#include <metalang99/priv/util.h> + +#include <metalang99/bool.h> +#include <metalang99/choice.h> +#include <metalang99/ident.h> + +/** + * Some value @p x. + */ +#define ML99_just(x) ML99_call(ML99_just, x) + +/** + * No value. + */ +#define ML99_nothing(...) ML99_callUneval(ML99_nothing, ) + +/** + * `ML99_true()` if @p maybe contains some value, otherwise `ML99_false()`. + * + * # Examples + * + * @code + * #include <metalang99/maybe.h> + * + * // 1 + * ML99_isJust(ML99_just(v(123))) + * + * // 0 + * ML99_isJust(ML99_nothing()) + * @endcode + */ +#define ML99_isJust(maybe) ML99_call(ML99_isJust, maybe) + +/** + * The inverse of #ML99_isJust. + * + * # Examples + * + * @code + * #include <metalang99/maybe.h> + * + * // 1 + * ML99_isNothing(ML99_nothing()) + * + * // 0 + * ML99_isNothing(ML99_just(v(123))) + * @endcode + */ +#define ML99_isNothing(maybe) ML99_call(ML99_isNothing, maybe) + +/** + * Tests @p maybe and @p other for equality. + * + * # Examples + * + * @code + * #include <metalang99/maybe.h> + * #include <metalang99/nat.h> + * + * // 1 + * ML99_maybeEq(v(ML99_natEq), ML99_just(v(123)), ML99_just(v(123))); + * + * // 0 + * ML99_maybeEq(v(ML99_natEq), ML99_just(v(4)), ML99_just(v(6))); + * + * // 0 + * ML99_maybeEq(v(ML99_natEq), ML99_just(v(4)), ML99_nothing()); + * @endcode + */ +#define ML99_maybeEq(cmp, maybe, other) ML99_call(ML99_maybeEq, cmp, maybe, other) + +/** + * Returns the contained value on `ML99_just(x)` or emits a fatal error on `ML99_nothing()`. + * + * # Examples + * + * @code + * #include <metalang99/maybe.h> + * + * // 123 + * ML99_maybeUnwrap(ML99_just(v(123))) + * + * // Emits a fatal error. + * ML99_maybeUnwrap(ML99_nothing()) + * @endcode + */ +#define ML99_maybeUnwrap(maybe) ML99_call(ML99_maybeUnwrap, maybe) + +#define ML99_JUST(x) ML99_CHOICE(just, x) +#define ML99_NOTHING(...) ML99_CHOICE(nothing, ~) +#define ML99_IS_JUST(maybe) ML99_PRIV_IS_JUST(maybe) +#define ML99_IS_NOTHING(maybe) ML99_NOT(ML99_IS_JUST(maybe)) + +#ifndef DOXYGEN_IGNORE + +#define ML99_just_IMPL(x) v(ML99_JUST(x)) +#define ML99_nothing_IMPL(...) v(ML99_NOTHING()) + +#define ML99_isJust_IMPL(maybe) v(ML99_IS_JUST(maybe)) +#define ML99_isNothing_IMPL(maybe) v(ML99_IS_NOTHING(maybe)) + +// ML99_maybeEq_IMPL { + +#define ML99_maybeEq_IMPL(cmp, maybe, other) \ + ML99_matchWithArgs_IMPL(maybe, ML99_PRIV_maybeEq_, cmp, other) + +#define ML99_PRIV_maybeEq_just_IMPL(x, cmp, other) \ + ML99_matchWithArgs_IMPL(other, ML99_PRIV_maybeEq_just_, cmp, x) +#define ML99_PRIV_maybeEq_nothing_IMPL(_, _cmp, other) v(ML99_IS_NOTHING(other)) + +#define ML99_PRIV_maybeEq_just_just_IMPL(y, cmp, x) ML99_appl2_IMPL(cmp, x, y) +#define ML99_PRIV_maybeEq_just_nothing_IMPL ML99_false_IMPL +// } (ML99_maybeEq_IMPL) + +#define ML99_maybeUnwrap_IMPL(maybe) ML99_match_IMPL(maybe, ML99_PRIV_maybeUnwrap_) +#define ML99_PRIV_maybeUnwrap_just_IMPL(x) v(x) +#define ML99_PRIV_maybeUnwrap_nothing_IMPL(_) \ + ML99_fatal(ML99_maybeUnwrap, expected ML99_just but found ML99_nothing) + +#define ML99_PRIV_IS_JUST(maybe) ML99_DETECT_IDENT(ML99_PRIV_IS_JUST_, ML99_CHOICE_TAG(maybe)) +#define ML99_PRIV_IS_JUST_just () + +// Arity specifiers { + +#define ML99_just_ARITY 1 +#define ML99_nothing_ARITY 1 +#define ML99_isJust_ARITY 1 +#define ML99_isNothing_ARITY 1 +#define ML99_maybeEq_ARITY 3 +#define ML99_maybeUnwrap_ARITY 1 +// } (Arity specifiers) + +#endif // DOXYGEN_IGNORE + +#endif // ML99_MAYBE_H diff --git a/test/external/metalang99/include/metalang99/nat.h b/test/external/metalang99/include/metalang99/nat.h new file mode 100644 index 0000000..6c56076 --- /dev/null +++ b/test/external/metalang99/include/metalang99/nat.h @@ -0,0 +1,526 @@ +/** + * @file + * Natural numbers: [0; 255]. + * + * Most of the time, natural numbers are used for iteration; they are not meant for CPU-bound tasks + * such as Fibonacci numbers or factorials. + */ + +#ifndef ML99_NAT_H +#define ML99_NAT_H + +#include <metalang99/priv/bool.h> + +#include <metalang99/nat/dec.h> +#include <metalang99/nat/div.h> +#include <metalang99/nat/eq.h> +#include <metalang99/nat/inc.h> + +#include <metalang99/lang.h> + +/** + * \f$x + 1\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 6 + * ML99_inc(v(5)) + * @endcode + * + * @note If @p x is #ML99_NAT_MAX, the result is 0. + */ +#define ML99_inc(x) ML99_call(ML99_inc, x) + +/** + * \f$x - 1\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 4 + * ML99_dec(v(5)) + * @endcode + * + * @note If @p x is 0, the result is #ML99_NAT_MAX. + */ +#define ML99_dec(x) ML99_call(ML99_dec, x) + +/** + * Matches @p x against the two cases: if it is zero or positive. + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * #define MATCH_Z_IMPL() v(Billie) + * #define MATCH_S_IMPL(x) v(Jean ~ x) + * + * // Billie + * ML99_natMatch(v(0), v(MATCH_)) + * + * // Jean ~ 122 + * ML99_natMatch(v(123), v(MATCH_)) + * @endcode + * + * @note This function calls @p f with #ML99_call, so no partial application occurs, and so + * arity specifiers are not needed. + */ +#define ML99_natMatch(x, matcher) ML99_call(ML99_natMatch, x, matcher) + +/** + * The same as #ML99_natMatch but provides additional arguments to all branches. + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * #define MATCH_Z_IMPL(x, y, z) v(Billie ~ x y z) + * #define MATCH_S_IMPL(n, x, y, z) v(Jean ~ n ~ x y z) + * + * // Billie ~ 1 2 3 + * ML99_natMatchWithArgs(v(0), v(MATCH_), v(1, 2, 3)) + * + * // Jean ~ 122 ~ 1 2 3 + * ML99_natMatchWithArgs(v(123), v(MATCH_), v(1, 2, 3)) + * @endcode + */ +#define ML99_natMatchWithArgs(x, matcher, ...) \ + ML99_call(ML99_natMatchWithArgs, x, matcher, __VA_ARGS__) + +/** + * \f$x = y\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 1 + * ML99_natEq(v(5), v(5)) + * + * // 0 + * ML99_natEq(v(3), v(8)) + * @endcode + */ +#define ML99_natEq(x, y) ML99_call(ML99_natEq, x, y) + +/** + * \f$x \neq y\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 0 + * ML99_natNeq(v(5), v(5)) + * + * // 1 + * ML99_natNeq(v(3), v(8)) + * @endcode + */ +#define ML99_natNeq(x, y) ML99_call(ML99_natNeq, x, y) + +/** + * \f$x > y\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 1 + * ML99_greater(v(8), v(3)) + * + * // 0 + * ML99_greater(v(3), v(8)) + * @endcode + */ +#define ML99_greater(x, y) ML99_call(ML99_greater, x, y) + +/** + * \f$x \geq y\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 1 + * ML99_greaterEq(v(8), v(8)) + * + * // 0 + * ML99_greaterEq(v(3), v(8)) + * @endcode + */ +#define ML99_greaterEq(x, y) ML99_call(ML99_greaterEq, x, y) + +/** + * \f$x < y\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 1 + * ML99_lesser(v(3), v(8)) + * + * // 0 + * ML99_lesser(v(8), v(3)) + * @endcode + */ +#define ML99_lesser(x, y) ML99_call(ML99_lesser, x, y) + +/** + * \f$x \leq y\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 1 + * ML99_lesserEq(v(8), v(8)) + * + * // 0 + * ML99_lesserEq(v(8), v(3)) + * @endcode + */ +#define ML99_lesserEq(x, y) ML99_call(ML99_lesserEq, x, y) + +/** + * \f$x + y\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 11 + * ML99_add(v(5), v(6)) + * @endcode + */ +#define ML99_add(x, y) ML99_call(ML99_add, x, y) + +/** + * \f$x - y\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 6 + * ML99_sub(v(11), v(5)) + * @endcode + */ +#define ML99_sub(x, y) ML99_call(ML99_sub, x, y) + +/** + * \f$x * y\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 12 + * ML99_mul(v(3), v(4)) + * @endcode + */ +#define ML99_mul(x, y) ML99_call(ML99_mul, x, y) + +/** + * \f$\frac{x}{y}\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 3 + * ML99_div(v(12), v(4)) + * @endcode + * + * @note A compile-time error if \f$\frac{x}{y}\f$ is not a natural number. + */ +#define ML99_div(x, y) ML99_call(ML99_div, x, y) + +/** + * Like #ML99_div but returns `ML99_nothing()` is @p x is not divisible by @p y, + * otherwise `ML99_just(result)`. + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // ML99_just(3) + * ML99_divChecked(v(12), v(4)) + * + * // ML99_nothing() + * ML99_divChecked(v(14), v(5)) + * + * // ML99_nothing() + * ML99_divChecked(v(1), v(0)) + * @endcode + */ +#define ML99_divChecked(x, y) ML99_call(ML99_divChecked, x, y) + +/** + * Computes the remainder of division. + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 2 + * ML99_mod(v(8), v(3)) + * @endcode + * + * @note A compile-time error if @p y is 0. + */ +#define ML99_mod(x, y) ML99_call(ML99_mod, x, y) + +/** + * \f$x + y + z\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 15 + * ML99_add3(v(1), v(6), v(8)) + * @endcode + */ +#define ML99_add3(x, y, z) ML99_call(ML99_add3, x, y, z) + +/** + * \f$x - y - z\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 3 + * ML99_sub3(v(8), v(2), v(3)) + * @endcode + */ +#define ML99_sub3(x, y, z) ML99_call(ML99_sub3, x, y, z) + +/** + * \f$x * y * z\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 24 + * ML99_mul3(v(2), v(3), v(4)) + * @endcode + */ +#define ML99_mul3(x, y, z) ML99_call(ML99_mul3, x, y, z) + +/** + * \f$\frac{(\frac{x}{y})}{z}\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 5 + * ML99_div(v(30), v(3), v(2)) + * @endcode + * + * @note A compile-time error if \f$\frac{(\frac{x}{y})}{z}\f$ is not a natural number. + */ +#define ML99_div3(x, y, z) ML99_call(ML99_div3, x, y, z) + +/** + * \f$min(x, y)\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 5 + * ML99_min(v(5), v(7)) + * @endcode + */ +#define ML99_min(x, y) ML99_call(ML99_min, x, y) + +/** + * \f$max(x, y)\f$ + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * // 7 + * ML99_max(v(5), v(7)) + * @endcode + */ +#define ML99_max(x, y) ML99_call(ML99_max, x, y) + +/** + * Emits a fatal error if @p x is not a natural number, otherwise results in emptiness. + * + * # Examples + * + * @code + * #include <metalang99/nat.h> + * + * #define F_IMPL(x) ML99_TERMS(ML99_assertIsNat(v(x)), ML99_inc(v(x))) + * + * // 6 + * ML99_call(F, v(5)) + * + * // A compile-time number mismatch error. + * ML99_call(F, v(blah)) + * @endcode + */ +#define ML99_assertIsNat(x) ML99_call(ML99_assertIsNat, x) + +#define ML99_INC(x) ML99_PRIV_INC(x) +#define ML99_DEC(x) ML99_PRIV_DEC(x) +#define ML99_NAT_EQ(x, y) ML99_PRIV_NAT_EQ(x, y) +#define ML99_NAT_NEQ(x, y) ML99_PRIV_NOT(ML99_NAT_EQ(x, y)) +#define ML99_DIV_CHECKED(x, y) ML99_PRIV_DIV_CHECKED(x, y) + +/** + * The maximum value of a natural number, currently 255. + */ +#define ML99_NAT_MAX 255 + +#ifndef DOXYGEN_IGNORE + +// Pattern matching { + +#define ML99_natMatch_IMPL(x, matcher) \ + ML99_PRIV_IF( \ + ML99_NAT_EQ(x, 0), \ + ML99_callUneval(matcher##Z, ), \ + ML99_callUneval(matcher##S, ML99_DEC(x))) + +#define ML99_natMatchWithArgs_IMPL(x, matcher, ...) \ + ML99_PRIV_IF( \ + ML99_NAT_EQ(x, 0), \ + ML99_callUneval(matcher##Z, __VA_ARGS__), \ + ML99_callUneval(matcher##S, ML99_DEC(x), __VA_ARGS__)) +// } (Pattern matching) + +// Comparison operators { + +#define ML99_natEq_IMPL(x, y) v(ML99_NAT_EQ(x, y)) +#define ML99_natNeq_IMPL(x, y) v(ML99_NAT_NEQ(x, y)) + +#define ML99_lesser_IMPL(x, y) \ + ML99_PRIV_IF( \ + ML99_NAT_EQ(y, 0), \ + v(ML99_PRIV_FALSE()), \ + ML99_PRIV_IF( \ + ML99_NAT_EQ(x, ML99_DEC(y)), \ + v(ML99_PRIV_TRUE()), \ + ML99_callUneval(ML99_lesser, x, ML99_DEC(y)))) + +#define ML99_lesserEq_IMPL(x, y) ML99_greaterEq_IMPL(y, x) + +#define ML99_greater_IMPL(x, y) ML99_lesser_IMPL(y, x) +#define ML99_greaterEq_IMPL(x, y) \ + ML99_PRIV_IF(ML99_NAT_EQ(x, y), v(ML99_PRIV_TRUE()), ML99_greater_IMPL(x, y)) +// } (Comparison operators) + +// Arithmetical operators { + +#define ML99_inc_IMPL(x) v(ML99_INC(x)) +#define ML99_dec_IMPL(x) v(ML99_DEC(x)) + +#define ML99_add_IMPL(x, y) \ + ML99_PRIV_IF(ML99_NAT_EQ(y, 0), v(x), ML99_callUneval(ML99_add, ML99_INC(x), ML99_DEC(y))) +#define ML99_sub_IMPL(x, y) \ + ML99_PRIV_IF(ML99_NAT_EQ(y, 0), v(x), ML99_callUneval(ML99_sub, ML99_DEC(x), ML99_DEC(y))) +#define ML99_mul_IMPL(x, y) \ + ML99_PRIV_IF(ML99_NAT_EQ(y, 0), v(0), ML99_add(v(x), ML99_callUneval(ML99_mul, x, ML99_DEC(y)))) + +#define ML99_add3_IMPL(x, y, z) ML99_add(ML99_add_IMPL(x, y), v(z)) +#define ML99_sub3_IMPL(x, y, z) ML99_sub(ML99_sub_IMPL(x, y), v(z)) +#define ML99_mul3_IMPL(x, y, z) ML99_mul(ML99_mul_IMPL(x, y), v(z)) +#define ML99_div3_IMPL(x, y, z) ML99_div(ML99_div_IMPL(x, y), v(z)) + +#define ML99_min_IMPL(x, y) ML99_call(ML99_if, ML99_lesser_IMPL(x, y), v(x, y)) +#define ML99_max_IMPL(x, y) ML99_call(ML99_if, ML99_lesser_IMPL(x, y), v(y, x)) + +#define ML99_divChecked_IMPL(x, y) v(ML99_DIV_CHECKED(x, y)) + +// ML99_mod_IMPL { + +#define ML99_mod_IMPL(x, y) \ + ML99_PRIV_IF( \ + ML99_NAT_EQ(y, 0), \ + ML99_fatal(ML99_mod, modulo by 0), \ + ML99_PRIV_modAux_IMPL(x, y, 0)) + +#define ML99_PRIV_modAux_IMPL(x, y, acc) \ + ML99_PRIV_IF( \ + ML99_PRIV_OR(ML99_NAT_EQ(x, 0), ML99_IS_JUST(ML99_DIV_CHECKED(x, y))), \ + v(acc), \ + ML99_callUneval(ML99_PRIV_modAux, ML99_DEC(x), y, ML99_INC(acc))) +// } (ML99_mod_IMPL) + +// } (Arithmetical operators) + +#define ML99_assertIsNat_IMPL(x) \ + ML99_PRIV_IF( \ + ML99_PRIV_NAT_EQ(x, x), \ + v(ML99_PRIV_EMPTY()), \ + ML99_PRIV_ASSERT_IS_NAT_FATAL(x, ML99_NAT_MAX)) + +// clang-format off +#define ML99_PRIV_ASSERT_IS_NAT_FATAL(x, max) ML99_fatal(ML99_assertIsNat, x must be within [0; max]) +// clang-format on + +// Arity specifiers { + +#define ML99_inc_ARITY 1 +#define ML99_dec_ARITY 1 +#define ML99_natMatch_ARITY 2 +#define ML99_natMatchWithArgs_ARITY 3 +#define ML99_natEq_ARITY 2 +#define ML99_natNeq_ARITY 2 +#define ML99_greater_ARITY 2 +#define ML99_greaterEq_ARITY 2 +#define ML99_lesser_ARITY 2 +#define ML99_lesserEq_ARITY 2 +#define ML99_add_ARITY 2 +#define ML99_sub_ARITY 2 +#define ML99_mul_ARITY 2 +#define ML99_div_ARITY 2 +#define ML99_divChecked_ARITY 2 +#define ML99_mod_ARITY 2 +#define ML99_add3_ARITY 3 +#define ML99_sub3_ARITY 3 +#define ML99_mul3_ARITY 3 +#define ML99_div3_ARITY 3 +#define ML99_min_ARITY 2 +#define ML99_max_ARITY 2 +#define ML99_assertIsNat_ARITY 1 +// } (Arity specifiers) + +#endif // DOXYGEN_IGNORE + +#endif // ML99_NAT_H diff --git a/test/external/metalang99/include/metalang99/nat/dec.h b/test/external/metalang99/include/metalang99/nat/dec.h new file mode 100644 index 0000000..f58dba8 --- /dev/null +++ b/test/external/metalang99/include/metalang99/nat/dec.h @@ -0,0 +1,264 @@ +#ifndef ML99_NAT_DEC_H +#define ML99_NAT_DEC_H + +#define ML99_PRIV_DEC(x) ML99_PRIV_DEC_AUX(x) +#define ML99_PRIV_DEC_AUX(x) ML99_PRIV_DEC_##x + +#define ML99_PRIV_DEC_0 255 +#define ML99_PRIV_DEC_1 0 +#define ML99_PRIV_DEC_2 1 +#define ML99_PRIV_DEC_3 2 +#define ML99_PRIV_DEC_4 3 +#define ML99_PRIV_DEC_5 4 +#define ML99_PRIV_DEC_6 5 +#define ML99_PRIV_DEC_7 6 +#define ML99_PRIV_DEC_8 7 +#define ML99_PRIV_DEC_9 8 +#define ML99_PRIV_DEC_10 9 +#define ML99_PRIV_DEC_11 10 +#define ML99_PRIV_DEC_12 11 +#define ML99_PRIV_DEC_13 12 +#define ML99_PRIV_DEC_14 13 +#define ML99_PRIV_DEC_15 14 +#define ML99_PRIV_DEC_16 15 +#define ML99_PRIV_DEC_17 16 +#define ML99_PRIV_DEC_18 17 +#define ML99_PRIV_DEC_19 18 +#define ML99_PRIV_DEC_20 19 +#define ML99_PRIV_DEC_21 20 +#define ML99_PRIV_DEC_22 21 +#define ML99_PRIV_DEC_23 22 +#define ML99_PRIV_DEC_24 23 +#define ML99_PRIV_DEC_25 24 +#define ML99_PRIV_DEC_26 25 +#define ML99_PRIV_DEC_27 26 +#define ML99_PRIV_DEC_28 27 +#define ML99_PRIV_DEC_29 28 +#define ML99_PRIV_DEC_30 29 +#define ML99_PRIV_DEC_31 30 +#define ML99_PRIV_DEC_32 31 +#define ML99_PRIV_DEC_33 32 +#define ML99_PRIV_DEC_34 33 +#define ML99_PRIV_DEC_35 34 +#define ML99_PRIV_DEC_36 35 +#define ML99_PRIV_DEC_37 36 +#define ML99_PRIV_DEC_38 37 +#define ML99_PRIV_DEC_39 38 +#define ML99_PRIV_DEC_40 39 +#define ML99_PRIV_DEC_41 40 +#define ML99_PRIV_DEC_42 41 +#define ML99_PRIV_DEC_43 42 +#define ML99_PRIV_DEC_44 43 +#define ML99_PRIV_DEC_45 44 +#define ML99_PRIV_DEC_46 45 +#define ML99_PRIV_DEC_47 46 +#define ML99_PRIV_DEC_48 47 +#define ML99_PRIV_DEC_49 48 +#define ML99_PRIV_DEC_50 49 +#define ML99_PRIV_DEC_51 50 +#define ML99_PRIV_DEC_52 51 +#define ML99_PRIV_DEC_53 52 +#define ML99_PRIV_DEC_54 53 +#define ML99_PRIV_DEC_55 54 +#define ML99_PRIV_DEC_56 55 +#define ML99_PRIV_DEC_57 56 +#define ML99_PRIV_DEC_58 57 +#define ML99_PRIV_DEC_59 58 +#define ML99_PRIV_DEC_60 59 +#define ML99_PRIV_DEC_61 60 +#define ML99_PRIV_DEC_62 61 +#define ML99_PRIV_DEC_63 62 +#define ML99_PRIV_DEC_64 63 +#define ML99_PRIV_DEC_65 64 +#define ML99_PRIV_DEC_66 65 +#define ML99_PRIV_DEC_67 66 +#define ML99_PRIV_DEC_68 67 +#define ML99_PRIV_DEC_69 68 +#define ML99_PRIV_DEC_70 69 +#define ML99_PRIV_DEC_71 70 +#define ML99_PRIV_DEC_72 71 +#define ML99_PRIV_DEC_73 72 +#define ML99_PRIV_DEC_74 73 +#define ML99_PRIV_DEC_75 74 +#define ML99_PRIV_DEC_76 75 +#define ML99_PRIV_DEC_77 76 +#define ML99_PRIV_DEC_78 77 +#define ML99_PRIV_DEC_79 78 +#define ML99_PRIV_DEC_80 79 +#define ML99_PRIV_DEC_81 80 +#define ML99_PRIV_DEC_82 81 +#define ML99_PRIV_DEC_83 82 +#define ML99_PRIV_DEC_84 83 +#define ML99_PRIV_DEC_85 84 +#define ML99_PRIV_DEC_86 85 +#define ML99_PRIV_DEC_87 86 +#define ML99_PRIV_DEC_88 87 +#define ML99_PRIV_DEC_89 88 +#define ML99_PRIV_DEC_90 89 +#define ML99_PRIV_DEC_91 90 +#define ML99_PRIV_DEC_92 91 +#define ML99_PRIV_DEC_93 92 +#define ML99_PRIV_DEC_94 93 +#define ML99_PRIV_DEC_95 94 +#define ML99_PRIV_DEC_96 95 +#define ML99_PRIV_DEC_97 96 +#define ML99_PRIV_DEC_98 97 +#define ML99_PRIV_DEC_99 98 +#define ML99_PRIV_DEC_100 99 +#define ML99_PRIV_DEC_101 100 +#define ML99_PRIV_DEC_102 101 +#define ML99_PRIV_DEC_103 102 +#define ML99_PRIV_DEC_104 103 +#define ML99_PRIV_DEC_105 104 +#define ML99_PRIV_DEC_106 105 +#define ML99_PRIV_DEC_107 106 +#define ML99_PRIV_DEC_108 107 +#define ML99_PRIV_DEC_109 108 +#define ML99_PRIV_DEC_110 109 +#define ML99_PRIV_DEC_111 110 +#define ML99_PRIV_DEC_112 111 +#define ML99_PRIV_DEC_113 112 +#define ML99_PRIV_DEC_114 113 +#define ML99_PRIV_DEC_115 114 +#define ML99_PRIV_DEC_116 115 +#define ML99_PRIV_DEC_117 116 +#define ML99_PRIV_DEC_118 117 +#define ML99_PRIV_DEC_119 118 +#define ML99_PRIV_DEC_120 119 +#define ML99_PRIV_DEC_121 120 +#define ML99_PRIV_DEC_122 121 +#define ML99_PRIV_DEC_123 122 +#define ML99_PRIV_DEC_124 123 +#define ML99_PRIV_DEC_125 124 +#define ML99_PRIV_DEC_126 125 +#define ML99_PRIV_DEC_127 126 +#define ML99_PRIV_DEC_128 127 +#define ML99_PRIV_DEC_129 128 +#define ML99_PRIV_DEC_130 129 +#define ML99_PRIV_DEC_131 130 +#define ML99_PRIV_DEC_132 131 +#define ML99_PRIV_DEC_133 132 +#define ML99_PRIV_DEC_134 133 +#define ML99_PRIV_DEC_135 134 +#define ML99_PRIV_DEC_136 135 +#define ML99_PRIV_DEC_137 136 +#define ML99_PRIV_DEC_138 137 +#define ML99_PRIV_DEC_139 138 +#define ML99_PRIV_DEC_140 139 +#define ML99_PRIV_DEC_141 140 +#define ML99_PRIV_DEC_142 141 +#define ML99_PRIV_DEC_143 142 +#define ML99_PRIV_DEC_144 143 +#define ML99_PRIV_DEC_145 144 +#define ML99_PRIV_DEC_146 145 +#define ML99_PRIV_DEC_147 146 +#define ML99_PRIV_DEC_148 147 +#define ML99_PRIV_DEC_149 148 +#define ML99_PRIV_DEC_150 149 +#define ML99_PRIV_DEC_151 150 +#define ML99_PRIV_DEC_152 151 +#define ML99_PRIV_DEC_153 152 +#define ML99_PRIV_DEC_154 153 +#define ML99_PRIV_DEC_155 154 +#define ML99_PRIV_DEC_156 155 +#define ML99_PRIV_DEC_157 156 +#define ML99_PRIV_DEC_158 157 +#define ML99_PRIV_DEC_159 158 +#define ML99_PRIV_DEC_160 159 +#define ML99_PRIV_DEC_161 160 +#define ML99_PRIV_DEC_162 161 +#define ML99_PRIV_DEC_163 162 +#define ML99_PRIV_DEC_164 163 +#define ML99_PRIV_DEC_165 164 +#define ML99_PRIV_DEC_166 165 +#define ML99_PRIV_DEC_167 166 +#define ML99_PRIV_DEC_168 167 +#define ML99_PRIV_DEC_169 168 +#define ML99_PRIV_DEC_170 169 +#define ML99_PRIV_DEC_171 170 +#define ML99_PRIV_DEC_172 171 +#define ML99_PRIV_DEC_173 172 +#define ML99_PRIV_DEC_174 173 +#define ML99_PRIV_DEC_175 174 +#define ML99_PRIV_DEC_176 175 +#define ML99_PRIV_DEC_177 176 +#define ML99_PRIV_DEC_178 177 +#define ML99_PRIV_DEC_179 178 +#define ML99_PRIV_DEC_180 179 +#define ML99_PRIV_DEC_181 180 +#define ML99_PRIV_DEC_182 181 +#define ML99_PRIV_DEC_183 182 +#define ML99_PRIV_DEC_184 183 +#define ML99_PRIV_DEC_185 184 +#define ML99_PRIV_DEC_186 185 +#define ML99_PRIV_DEC_187 186 +#define ML99_PRIV_DEC_188 187 +#define ML99_PRIV_DEC_189 188 +#define ML99_PRIV_DEC_190 189 +#define ML99_PRIV_DEC_191 190 +#define ML99_PRIV_DEC_192 191 +#define ML99_PRIV_DEC_193 192 +#define ML99_PRIV_DEC_194 193 +#define ML99_PRIV_DEC_195 194 +#define ML99_PRIV_DEC_196 195 +#define ML99_PRIV_DEC_197 196 +#define ML99_PRIV_DEC_198 197 +#define ML99_PRIV_DEC_199 198 +#define ML99_PRIV_DEC_200 199 +#define ML99_PRIV_DEC_201 200 +#define ML99_PRIV_DEC_202 201 +#define ML99_PRIV_DEC_203 202 +#define ML99_PRIV_DEC_204 203 +#define ML99_PRIV_DEC_205 204 +#define ML99_PRIV_DEC_206 205 +#define ML99_PRIV_DEC_207 206 +#define ML99_PRIV_DEC_208 207 +#define ML99_PRIV_DEC_209 208 +#define ML99_PRIV_DEC_210 209 +#define ML99_PRIV_DEC_211 210 +#define ML99_PRIV_DEC_212 211 +#define ML99_PRIV_DEC_213 212 +#define ML99_PRIV_DEC_214 213 +#define ML99_PRIV_DEC_215 214 +#define ML99_PRIV_DEC_216 215 +#define ML99_PRIV_DEC_217 216 +#define ML99_PRIV_DEC_218 217 +#define ML99_PRIV_DEC_219 218 +#define ML99_PRIV_DEC_220 219 +#define ML99_PRIV_DEC_221 220 +#define ML99_PRIV_DEC_222 221 +#define ML99_PRIV_DEC_223 222 +#define ML99_PRIV_DEC_224 223 +#define ML99_PRIV_DEC_225 224 +#define ML99_PRIV_DEC_226 225 +#define ML99_PRIV_DEC_227 226 +#define ML99_PRIV_DEC_228 227 +#define ML99_PRIV_DEC_229 228 +#define ML99_PRIV_DEC_230 229 +#define ML99_PRIV_DEC_231 230 +#define ML99_PRIV_DEC_232 231 +#define ML99_PRIV_DEC_233 232 +#define ML99_PRIV_DEC_234 233 +#define ML99_PRIV_DEC_235 234 +#define ML99_PRIV_DEC_236 235 +#define ML99_PRIV_DEC_237 236 +#define ML99_PRIV_DEC_238 237 +#define ML99_PRIV_DEC_239 238 +#define ML99_PRIV_DEC_240 239 +#define ML99_PRIV_DEC_241 240 +#define ML99_PRIV_DEC_242 241 +#define ML99_PRIV_DEC_243 242 +#define ML99_PRIV_DEC_244 243 +#define ML99_PRIV_DEC_245 244 +#define ML99_PRIV_DEC_246 245 +#define ML99_PRIV_DEC_247 246 +#define ML99_PRIV_DEC_248 247 +#define ML99_PRIV_DEC_249 248 +#define ML99_PRIV_DEC_250 249 +#define ML99_PRIV_DEC_251 250 +#define ML99_PRIV_DEC_252 251 +#define ML99_PRIV_DEC_253 252 +#define ML99_PRIV_DEC_254 253 +#define ML99_PRIV_DEC_255 254 + +#endif // ML99_NAT_DEC_H diff --git a/test/external/metalang99/include/metalang99/nat/div.h b/test/external/metalang99/include/metalang99/nat/div.h new file mode 100644 index 0000000..ebd0b13 --- /dev/null +++ b/test/external/metalang99/include/metalang99/nat/div.h @@ -0,0 +1,1172 @@ +#ifndef ML99_NAT_DIV_H +#define ML99_NAT_DIV_H + +#include <metalang99/priv/bool.h> +#include <metalang99/priv/util.h> + +#include <metalang99/maybe.h> +#include <metalang99/tuple.h> + +#define ML99_div_IMPL(x, y) \ + ML99_matchWithArgs_IMPL(ML99_PRIV_DIV_CHECKED(x, y), ML99_PRIV_DIV_, x, y) +#define ML99_PRIV_DIV_nothing_IMPL(_, x, y) ML99_fatal(ML99_div, x is not divisible by y) +#define ML99_PRIV_DIV_just_IMPL(n, _x, _y) v(n) + +#define ML99_PRIV_DIV_CHECKED(x, y) \ + ML99_PRIV_IF( \ + ML99_PRIV_NAT_EQ(y, 1), \ + ML99_JUST(x), \ + ML99_PRIV_IF( \ + ML99_PRIV_NAT_EQ(x, y), \ + ML99_JUST(1), \ + ML99_UNTUPLE(ML99_PRIV_SND(ML99_PRIV_DIV_##x##_##y, (ML99_NOTHING()))))) + +#define ML99_PRIV_DIV_4_2 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_6_2 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_6_3 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_8_2 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_8_4 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_9_3 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_10_2 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_10_5 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_12_2 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_12_3 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_12_4 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_12_6 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_14_2 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_14_7 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_15_3 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_15_5 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_16_2 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_16_4 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_16_8 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_18_2 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_18_3 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_18_6 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_18_9 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_20_2 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_20_4 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_20_5 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_20_10 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_21_3 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_21_7 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_22_2 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_22_11 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_24_2 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_24_3 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_24_4 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_24_6 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_24_8 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_24_12 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_25_5 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_26_2 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_26_13 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_27_3 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_27_9 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_28_2 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_28_4 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_28_7 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_28_14 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_30_2 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_30_3 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_30_5 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_30_6 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_30_10 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_30_15 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_32_2 ~, (ML99_JUST(16)) +#define ML99_PRIV_DIV_32_4 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_32_8 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_32_16 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_33_3 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_33_11 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_34_2 ~, (ML99_JUST(17)) +#define ML99_PRIV_DIV_34_17 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_35_5 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_35_7 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_36_2 ~, (ML99_JUST(18)) +#define ML99_PRIV_DIV_36_3 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_36_4 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_36_6 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_36_9 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_36_12 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_36_18 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_38_2 ~, (ML99_JUST(19)) +#define ML99_PRIV_DIV_38_19 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_39_3 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_39_13 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_40_2 ~, (ML99_JUST(20)) +#define ML99_PRIV_DIV_40_4 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_40_5 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_40_8 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_40_10 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_40_20 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_42_2 ~, (ML99_JUST(21)) +#define ML99_PRIV_DIV_42_3 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_42_6 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_42_7 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_42_14 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_42_21 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_44_2 ~, (ML99_JUST(22)) +#define ML99_PRIV_DIV_44_4 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_44_11 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_44_22 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_45_3 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_45_5 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_45_9 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_45_15 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_46_2 ~, (ML99_JUST(23)) +#define ML99_PRIV_DIV_46_23 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_48_2 ~, (ML99_JUST(24)) +#define ML99_PRIV_DIV_48_3 ~, (ML99_JUST(16)) +#define ML99_PRIV_DIV_48_4 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_48_6 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_48_8 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_48_12 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_48_16 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_48_24 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_49_7 ~, (ML99_JUST(7)) + +#define ML99_PRIV_DIV_50_2 ~, (ML99_JUST(25)) +#define ML99_PRIV_DIV_50_5 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_50_10 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_50_25 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_51_3 ~, (ML99_JUST(17)) +#define ML99_PRIV_DIV_51_17 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_52_2 ~, (ML99_JUST(26)) +#define ML99_PRIV_DIV_52_4 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_52_13 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_52_26 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_54_2 ~, (ML99_JUST(27)) +#define ML99_PRIV_DIV_54_3 ~, (ML99_JUST(18)) +#define ML99_PRIV_DIV_54_6 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_54_9 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_54_18 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_54_27 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_55_5 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_55_11 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_56_2 ~, (ML99_JUST(28)) +#define ML99_PRIV_DIV_56_4 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_56_7 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_56_8 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_56_14 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_56_28 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_57_3 ~, (ML99_JUST(19)) +#define ML99_PRIV_DIV_57_19 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_58_2 ~, (ML99_JUST(29)) +#define ML99_PRIV_DIV_58_29 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_60_2 ~, (ML99_JUST(30)) +#define ML99_PRIV_DIV_60_3 ~, (ML99_JUST(20)) +#define ML99_PRIV_DIV_60_4 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_60_5 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_60_6 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_60_10 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_60_12 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_60_15 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_60_20 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_60_30 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_62_2 ~, (ML99_JUST(31)) +#define ML99_PRIV_DIV_62_31 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_63_3 ~, (ML99_JUST(21)) +#define ML99_PRIV_DIV_63_7 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_63_9 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_63_21 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_64_2 ~, (ML99_JUST(32)) +#define ML99_PRIV_DIV_64_4 ~, (ML99_JUST(16)) +#define ML99_PRIV_DIV_64_8 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_64_16 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_64_32 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_65_5 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_65_13 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_66_2 ~, (ML99_JUST(33)) +#define ML99_PRIV_DIV_66_3 ~, (ML99_JUST(22)) +#define ML99_PRIV_DIV_66_6 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_66_11 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_66_22 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_66_33 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_68_2 ~, (ML99_JUST(34)) +#define ML99_PRIV_DIV_68_4 ~, (ML99_JUST(17)) +#define ML99_PRIV_DIV_68_17 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_68_34 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_69_3 ~, (ML99_JUST(23)) +#define ML99_PRIV_DIV_69_23 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_70_2 ~, (ML99_JUST(35)) +#define ML99_PRIV_DIV_70_5 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_70_7 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_70_10 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_70_14 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_70_35 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_72_2 ~, (ML99_JUST(36)) +#define ML99_PRIV_DIV_72_3 ~, (ML99_JUST(24)) +#define ML99_PRIV_DIV_72_4 ~, (ML99_JUST(18)) +#define ML99_PRIV_DIV_72_6 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_72_8 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_72_9 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_72_12 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_72_18 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_72_24 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_72_36 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_74_2 ~, (ML99_JUST(37)) +#define ML99_PRIV_DIV_74_37 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_75_3 ~, (ML99_JUST(25)) +#define ML99_PRIV_DIV_75_5 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_75_15 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_75_25 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_76_2 ~, (ML99_JUST(38)) +#define ML99_PRIV_DIV_76_4 ~, (ML99_JUST(19)) +#define ML99_PRIV_DIV_76_19 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_76_38 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_77_7 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_77_11 ~, (ML99_JUST(7)) + +#define ML99_PRIV_DIV_78_2 ~, (ML99_JUST(39)) +#define ML99_PRIV_DIV_78_3 ~, (ML99_JUST(26)) +#define ML99_PRIV_DIV_78_6 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_78_13 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_78_26 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_78_39 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_80_2 ~, (ML99_JUST(40)) +#define ML99_PRIV_DIV_80_4 ~, (ML99_JUST(20)) +#define ML99_PRIV_DIV_80_5 ~, (ML99_JUST(16)) +#define ML99_PRIV_DIV_80_8 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_80_10 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_80_16 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_80_20 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_80_40 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_81_3 ~, (ML99_JUST(27)) +#define ML99_PRIV_DIV_81_9 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_81_27 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_82_2 ~, (ML99_JUST(41)) +#define ML99_PRIV_DIV_82_41 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_84_2 ~, (ML99_JUST(42)) +#define ML99_PRIV_DIV_84_3 ~, (ML99_JUST(28)) +#define ML99_PRIV_DIV_84_4 ~, (ML99_JUST(21)) +#define ML99_PRIV_DIV_84_6 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_84_7 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_84_12 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_84_14 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_84_21 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_84_28 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_84_42 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_85_5 ~, (ML99_JUST(17)) +#define ML99_PRIV_DIV_85_17 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_86_2 ~, (ML99_JUST(43)) +#define ML99_PRIV_DIV_86_43 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_87_3 ~, (ML99_JUST(29)) +#define ML99_PRIV_DIV_87_29 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_88_2 ~, (ML99_JUST(44)) +#define ML99_PRIV_DIV_88_4 ~, (ML99_JUST(22)) +#define ML99_PRIV_DIV_88_8 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_88_11 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_88_22 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_88_44 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_90_2 ~, (ML99_JUST(45)) +#define ML99_PRIV_DIV_90_3 ~, (ML99_JUST(30)) +#define ML99_PRIV_DIV_90_5 ~, (ML99_JUST(18)) +#define ML99_PRIV_DIV_90_6 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_90_9 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_90_10 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_90_15 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_90_18 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_90_30 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_90_45 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_91_7 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_91_13 ~, (ML99_JUST(7)) + +#define ML99_PRIV_DIV_92_2 ~, (ML99_JUST(46)) +#define ML99_PRIV_DIV_92_4 ~, (ML99_JUST(23)) +#define ML99_PRIV_DIV_92_23 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_92_46 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_93_3 ~, (ML99_JUST(31)) +#define ML99_PRIV_DIV_93_31 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_94_2 ~, (ML99_JUST(47)) +#define ML99_PRIV_DIV_94_47 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_95_5 ~, (ML99_JUST(19)) +#define ML99_PRIV_DIV_95_19 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_96_2 ~, (ML99_JUST(48)) +#define ML99_PRIV_DIV_96_3 ~, (ML99_JUST(32)) +#define ML99_PRIV_DIV_96_4 ~, (ML99_JUST(24)) +#define ML99_PRIV_DIV_96_6 ~, (ML99_JUST(16)) +#define ML99_PRIV_DIV_96_8 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_96_12 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_96_16 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_96_24 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_96_32 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_96_48 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_98_2 ~, (ML99_JUST(49)) +#define ML99_PRIV_DIV_98_7 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_98_14 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_98_49 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_99_3 ~, (ML99_JUST(33)) +#define ML99_PRIV_DIV_99_9 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_99_11 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_99_33 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_100_2 ~, (ML99_JUST(50)) +#define ML99_PRIV_DIV_100_4 ~, (ML99_JUST(25)) +#define ML99_PRIV_DIV_100_5 ~, (ML99_JUST(20)) +#define ML99_PRIV_DIV_100_10 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_100_20 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_100_25 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_100_50 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_102_2 ~, (ML99_JUST(51)) +#define ML99_PRIV_DIV_102_3 ~, (ML99_JUST(34)) +#define ML99_PRIV_DIV_102_6 ~, (ML99_JUST(17)) +#define ML99_PRIV_DIV_102_17 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_102_34 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_102_51 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_104_2 ~, (ML99_JUST(52)) +#define ML99_PRIV_DIV_104_4 ~, (ML99_JUST(26)) +#define ML99_PRIV_DIV_104_8 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_104_13 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_104_26 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_104_52 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_105_3 ~, (ML99_JUST(35)) +#define ML99_PRIV_DIV_105_5 ~, (ML99_JUST(21)) +#define ML99_PRIV_DIV_105_7 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_105_15 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_105_21 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_105_35 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_106_2 ~, (ML99_JUST(53)) +#define ML99_PRIV_DIV_106_53 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_108_2 ~, (ML99_JUST(54)) +#define ML99_PRIV_DIV_108_3 ~, (ML99_JUST(36)) +#define ML99_PRIV_DIV_108_4 ~, (ML99_JUST(27)) +#define ML99_PRIV_DIV_108_6 ~, (ML99_JUST(18)) +#define ML99_PRIV_DIV_108_9 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_108_12 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_108_18 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_108_27 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_108_36 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_108_54 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_110_2 ~, (ML99_JUST(55)) +#define ML99_PRIV_DIV_110_5 ~, (ML99_JUST(22)) +#define ML99_PRIV_DIV_110_10 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_110_11 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_110_22 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_110_55 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_111_3 ~, (ML99_JUST(37)) +#define ML99_PRIV_DIV_111_37 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_112_2 ~, (ML99_JUST(56)) +#define ML99_PRIV_DIV_112_4 ~, (ML99_JUST(28)) +#define ML99_PRIV_DIV_112_7 ~, (ML99_JUST(16)) +#define ML99_PRIV_DIV_112_8 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_112_14 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_112_16 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_112_28 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_112_56 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_114_2 ~, (ML99_JUST(57)) +#define ML99_PRIV_DIV_114_3 ~, (ML99_JUST(38)) +#define ML99_PRIV_DIV_114_6 ~, (ML99_JUST(19)) +#define ML99_PRIV_DIV_114_19 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_114_38 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_114_57 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_115_5 ~, (ML99_JUST(23)) +#define ML99_PRIV_DIV_115_23 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_116_2 ~, (ML99_JUST(58)) +#define ML99_PRIV_DIV_116_4 ~, (ML99_JUST(29)) +#define ML99_PRIV_DIV_116_29 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_116_58 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_117_3 ~, (ML99_JUST(39)) +#define ML99_PRIV_DIV_117_9 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_117_13 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_117_39 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_118_2 ~, (ML99_JUST(59)) +#define ML99_PRIV_DIV_118_59 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_119_7 ~, (ML99_JUST(17)) +#define ML99_PRIV_DIV_119_17 ~, (ML99_JUST(7)) + +#define ML99_PRIV_DIV_120_2 ~, (ML99_JUST(60)) +#define ML99_PRIV_DIV_120_3 ~, (ML99_JUST(40)) +#define ML99_PRIV_DIV_120_4 ~, (ML99_JUST(30)) +#define ML99_PRIV_DIV_120_5 ~, (ML99_JUST(24)) +#define ML99_PRIV_DIV_120_6 ~, (ML99_JUST(20)) +#define ML99_PRIV_DIV_120_8 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_120_10 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_120_12 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_120_15 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_120_20 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_120_24 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_120_30 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_120_40 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_120_60 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_121_11 ~, (ML99_JUST(11)) + +#define ML99_PRIV_DIV_122_2 ~, (ML99_JUST(61)) +#define ML99_PRIV_DIV_122_61 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_123_3 ~, (ML99_JUST(41)) +#define ML99_PRIV_DIV_123_41 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_124_2 ~, (ML99_JUST(62)) +#define ML99_PRIV_DIV_124_4 ~, (ML99_JUST(31)) +#define ML99_PRIV_DIV_124_31 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_124_62 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_125_5 ~, (ML99_JUST(25)) +#define ML99_PRIV_DIV_125_25 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_126_2 ~, (ML99_JUST(63)) +#define ML99_PRIV_DIV_126_3 ~, (ML99_JUST(42)) +#define ML99_PRIV_DIV_126_6 ~, (ML99_JUST(21)) +#define ML99_PRIV_DIV_126_7 ~, (ML99_JUST(18)) +#define ML99_PRIV_DIV_126_9 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_126_14 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_126_18 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_126_21 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_126_42 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_126_63 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_128_2 ~, (ML99_JUST(64)) +#define ML99_PRIV_DIV_128_4 ~, (ML99_JUST(32)) +#define ML99_PRIV_DIV_128_8 ~, (ML99_JUST(16)) +#define ML99_PRIV_DIV_128_16 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_128_32 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_128_64 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_129_3 ~, (ML99_JUST(43)) +#define ML99_PRIV_DIV_129_43 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_130_2 ~, (ML99_JUST(65)) +#define ML99_PRIV_DIV_130_5 ~, (ML99_JUST(26)) +#define ML99_PRIV_DIV_130_10 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_130_13 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_130_26 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_130_65 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_132_2 ~, (ML99_JUST(66)) +#define ML99_PRIV_DIV_132_3 ~, (ML99_JUST(44)) +#define ML99_PRIV_DIV_132_4 ~, (ML99_JUST(33)) +#define ML99_PRIV_DIV_132_6 ~, (ML99_JUST(22)) +#define ML99_PRIV_DIV_132_11 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_132_12 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_132_22 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_132_33 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_132_44 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_132_66 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_133_7 ~, (ML99_JUST(19)) +#define ML99_PRIV_DIV_133_19 ~, (ML99_JUST(7)) + +#define ML99_PRIV_DIV_134_2 ~, (ML99_JUST(67)) +#define ML99_PRIV_DIV_134_67 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_135_3 ~, (ML99_JUST(45)) +#define ML99_PRIV_DIV_135_5 ~, (ML99_JUST(27)) +#define ML99_PRIV_DIV_135_9 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_135_15 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_135_27 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_135_45 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_136_2 ~, (ML99_JUST(68)) +#define ML99_PRIV_DIV_136_4 ~, (ML99_JUST(34)) +#define ML99_PRIV_DIV_136_8 ~, (ML99_JUST(17)) +#define ML99_PRIV_DIV_136_17 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_136_34 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_136_68 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_138_2 ~, (ML99_JUST(69)) +#define ML99_PRIV_DIV_138_3 ~, (ML99_JUST(46)) +#define ML99_PRIV_DIV_138_6 ~, (ML99_JUST(23)) +#define ML99_PRIV_DIV_138_23 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_138_46 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_138_69 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_140_2 ~, (ML99_JUST(70)) +#define ML99_PRIV_DIV_140_4 ~, (ML99_JUST(35)) +#define ML99_PRIV_DIV_140_5 ~, (ML99_JUST(28)) +#define ML99_PRIV_DIV_140_7 ~, (ML99_JUST(20)) +#define ML99_PRIV_DIV_140_10 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_140_14 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_140_20 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_140_28 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_140_35 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_140_70 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_141_3 ~, (ML99_JUST(47)) +#define ML99_PRIV_DIV_141_47 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_142_2 ~, (ML99_JUST(71)) +#define ML99_PRIV_DIV_142_71 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_143_11 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_143_13 ~, (ML99_JUST(11)) + +#define ML99_PRIV_DIV_144_2 ~, (ML99_JUST(72)) +#define ML99_PRIV_DIV_144_3 ~, (ML99_JUST(48)) +#define ML99_PRIV_DIV_144_4 ~, (ML99_JUST(36)) +#define ML99_PRIV_DIV_144_6 ~, (ML99_JUST(24)) +#define ML99_PRIV_DIV_144_8 ~, (ML99_JUST(18)) +#define ML99_PRIV_DIV_144_9 ~, (ML99_JUST(16)) +#define ML99_PRIV_DIV_144_12 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_144_16 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_144_18 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_144_24 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_144_36 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_144_48 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_144_72 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_145_5 ~, (ML99_JUST(29)) +#define ML99_PRIV_DIV_145_29 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_146_2 ~, (ML99_JUST(73)) +#define ML99_PRIV_DIV_146_73 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_147_3 ~, (ML99_JUST(49)) +#define ML99_PRIV_DIV_147_7 ~, (ML99_JUST(21)) +#define ML99_PRIV_DIV_147_21 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_147_49 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_148_2 ~, (ML99_JUST(74)) +#define ML99_PRIV_DIV_148_4 ~, (ML99_JUST(37)) +#define ML99_PRIV_DIV_148_37 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_148_74 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_150_2 ~, (ML99_JUST(75)) +#define ML99_PRIV_DIV_150_3 ~, (ML99_JUST(50)) +#define ML99_PRIV_DIV_150_5 ~, (ML99_JUST(30)) +#define ML99_PRIV_DIV_150_6 ~, (ML99_JUST(25)) +#define ML99_PRIV_DIV_150_10 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_150_15 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_150_25 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_150_30 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_150_50 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_150_75 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_152_2 ~, (ML99_JUST(76)) +#define ML99_PRIV_DIV_152_4 ~, (ML99_JUST(38)) +#define ML99_PRIV_DIV_152_8 ~, (ML99_JUST(19)) +#define ML99_PRIV_DIV_152_19 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_152_38 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_152_76 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_153_3 ~, (ML99_JUST(51)) +#define ML99_PRIV_DIV_153_9 ~, (ML99_JUST(17)) +#define ML99_PRIV_DIV_153_17 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_153_51 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_154_2 ~, (ML99_JUST(77)) +#define ML99_PRIV_DIV_154_7 ~, (ML99_JUST(22)) +#define ML99_PRIV_DIV_154_11 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_154_14 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_154_22 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_154_77 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_155_5 ~, (ML99_JUST(31)) +#define ML99_PRIV_DIV_155_31 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_156_2 ~, (ML99_JUST(78)) +#define ML99_PRIV_DIV_156_3 ~, (ML99_JUST(52)) +#define ML99_PRIV_DIV_156_4 ~, (ML99_JUST(39)) +#define ML99_PRIV_DIV_156_6 ~, (ML99_JUST(26)) +#define ML99_PRIV_DIV_156_12 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_156_13 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_156_26 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_156_39 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_156_52 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_156_78 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_158_2 ~, (ML99_JUST(79)) +#define ML99_PRIV_DIV_158_79 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_159_3 ~, (ML99_JUST(53)) +#define ML99_PRIV_DIV_159_53 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_160_2 ~, (ML99_JUST(80)) +#define ML99_PRIV_DIV_160_4 ~, (ML99_JUST(40)) +#define ML99_PRIV_DIV_160_5 ~, (ML99_JUST(32)) +#define ML99_PRIV_DIV_160_8 ~, (ML99_JUST(20)) +#define ML99_PRIV_DIV_160_10 ~, (ML99_JUST(16)) +#define ML99_PRIV_DIV_160_16 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_160_20 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_160_32 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_160_40 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_160_80 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_161_7 ~, (ML99_JUST(23)) +#define ML99_PRIV_DIV_161_23 ~, (ML99_JUST(7)) + +#define ML99_PRIV_DIV_162_2 ~, (ML99_JUST(81)) +#define ML99_PRIV_DIV_162_3 ~, (ML99_JUST(54)) +#define ML99_PRIV_DIV_162_6 ~, (ML99_JUST(27)) +#define ML99_PRIV_DIV_162_9 ~, (ML99_JUST(18)) +#define ML99_PRIV_DIV_162_18 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_162_27 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_162_54 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_162_81 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_164_2 ~, (ML99_JUST(82)) +#define ML99_PRIV_DIV_164_4 ~, (ML99_JUST(41)) +#define ML99_PRIV_DIV_164_41 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_164_82 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_165_3 ~, (ML99_JUST(55)) +#define ML99_PRIV_DIV_165_5 ~, (ML99_JUST(33)) +#define ML99_PRIV_DIV_165_11 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_165_15 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_165_33 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_165_55 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_166_2 ~, (ML99_JUST(83)) +#define ML99_PRIV_DIV_166_83 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_168_2 ~, (ML99_JUST(84)) +#define ML99_PRIV_DIV_168_3 ~, (ML99_JUST(56)) +#define ML99_PRIV_DIV_168_4 ~, (ML99_JUST(42)) +#define ML99_PRIV_DIV_168_6 ~, (ML99_JUST(28)) +#define ML99_PRIV_DIV_168_7 ~, (ML99_JUST(24)) +#define ML99_PRIV_DIV_168_8 ~, (ML99_JUST(21)) +#define ML99_PRIV_DIV_168_12 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_168_14 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_168_21 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_168_24 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_168_28 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_168_42 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_168_56 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_168_84 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_169_13 ~, (ML99_JUST(13)) + +#define ML99_PRIV_DIV_170_2 ~, (ML99_JUST(85)) +#define ML99_PRIV_DIV_170_5 ~, (ML99_JUST(34)) +#define ML99_PRIV_DIV_170_10 ~, (ML99_JUST(17)) +#define ML99_PRIV_DIV_170_17 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_170_34 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_170_85 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_171_3 ~, (ML99_JUST(57)) +#define ML99_PRIV_DIV_171_9 ~, (ML99_JUST(19)) +#define ML99_PRIV_DIV_171_19 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_171_57 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_172_2 ~, (ML99_JUST(86)) +#define ML99_PRIV_DIV_172_4 ~, (ML99_JUST(43)) +#define ML99_PRIV_DIV_172_43 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_172_86 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_174_2 ~, (ML99_JUST(87)) +#define ML99_PRIV_DIV_174_3 ~, (ML99_JUST(58)) +#define ML99_PRIV_DIV_174_6 ~, (ML99_JUST(29)) +#define ML99_PRIV_DIV_174_29 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_174_58 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_174_87 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_175_5 ~, (ML99_JUST(35)) +#define ML99_PRIV_DIV_175_7 ~, (ML99_JUST(25)) +#define ML99_PRIV_DIV_175_25 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_175_35 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_176_2 ~, (ML99_JUST(88)) +#define ML99_PRIV_DIV_176_4 ~, (ML99_JUST(44)) +#define ML99_PRIV_DIV_176_8 ~, (ML99_JUST(22)) +#define ML99_PRIV_DIV_176_11 ~, (ML99_JUST(16)) +#define ML99_PRIV_DIV_176_16 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_176_22 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_176_44 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_176_88 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_177_3 ~, (ML99_JUST(59)) +#define ML99_PRIV_DIV_177_59 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_178_2 ~, (ML99_JUST(89)) +#define ML99_PRIV_DIV_178_89 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_180_2 ~, (ML99_JUST(90)) +#define ML99_PRIV_DIV_180_3 ~, (ML99_JUST(60)) +#define ML99_PRIV_DIV_180_4 ~, (ML99_JUST(45)) +#define ML99_PRIV_DIV_180_5 ~, (ML99_JUST(36)) +#define ML99_PRIV_DIV_180_6 ~, (ML99_JUST(30)) +#define ML99_PRIV_DIV_180_9 ~, (ML99_JUST(20)) +#define ML99_PRIV_DIV_180_10 ~, (ML99_JUST(18)) +#define ML99_PRIV_DIV_180_12 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_180_15 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_180_18 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_180_20 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_180_30 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_180_36 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_180_45 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_180_60 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_180_90 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_182_2 ~, (ML99_JUST(91)) +#define ML99_PRIV_DIV_182_7 ~, (ML99_JUST(26)) +#define ML99_PRIV_DIV_182_13 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_182_14 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_182_26 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_182_91 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_183_3 ~, (ML99_JUST(61)) +#define ML99_PRIV_DIV_183_61 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_184_2 ~, (ML99_JUST(92)) +#define ML99_PRIV_DIV_184_4 ~, (ML99_JUST(46)) +#define ML99_PRIV_DIV_184_8 ~, (ML99_JUST(23)) +#define ML99_PRIV_DIV_184_23 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_184_46 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_184_92 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_185_5 ~, (ML99_JUST(37)) +#define ML99_PRIV_DIV_185_37 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_186_2 ~, (ML99_JUST(93)) +#define ML99_PRIV_DIV_186_3 ~, (ML99_JUST(62)) +#define ML99_PRIV_DIV_186_6 ~, (ML99_JUST(31)) +#define ML99_PRIV_DIV_186_31 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_186_62 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_186_93 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_187_11 ~, (ML99_JUST(17)) +#define ML99_PRIV_DIV_187_17 ~, (ML99_JUST(11)) + +#define ML99_PRIV_DIV_188_2 ~, (ML99_JUST(94)) +#define ML99_PRIV_DIV_188_4 ~, (ML99_JUST(47)) +#define ML99_PRIV_DIV_188_47 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_188_94 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_189_3 ~, (ML99_JUST(63)) +#define ML99_PRIV_DIV_189_7 ~, (ML99_JUST(27)) +#define ML99_PRIV_DIV_189_9 ~, (ML99_JUST(21)) +#define ML99_PRIV_DIV_189_21 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_189_27 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_189_63 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_190_2 ~, (ML99_JUST(95)) +#define ML99_PRIV_DIV_190_5 ~, (ML99_JUST(38)) +#define ML99_PRIV_DIV_190_10 ~, (ML99_JUST(19)) +#define ML99_PRIV_DIV_190_19 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_190_38 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_190_95 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_192_2 ~, (ML99_JUST(96)) +#define ML99_PRIV_DIV_192_3 ~, (ML99_JUST(64)) +#define ML99_PRIV_DIV_192_4 ~, (ML99_JUST(48)) +#define ML99_PRIV_DIV_192_6 ~, (ML99_JUST(32)) +#define ML99_PRIV_DIV_192_8 ~, (ML99_JUST(24)) +#define ML99_PRIV_DIV_192_12 ~, (ML99_JUST(16)) +#define ML99_PRIV_DIV_192_16 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_192_24 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_192_32 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_192_48 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_192_64 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_192_96 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_194_2 ~, (ML99_JUST(97)) +#define ML99_PRIV_DIV_194_97 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_195_3 ~, (ML99_JUST(65)) +#define ML99_PRIV_DIV_195_5 ~, (ML99_JUST(39)) +#define ML99_PRIV_DIV_195_13 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_195_15 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_195_39 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_195_65 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_196_2 ~, (ML99_JUST(98)) +#define ML99_PRIV_DIV_196_4 ~, (ML99_JUST(49)) +#define ML99_PRIV_DIV_196_7 ~, (ML99_JUST(28)) +#define ML99_PRIV_DIV_196_14 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_196_28 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_196_49 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_196_98 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_198_2 ~, (ML99_JUST(99)) +#define ML99_PRIV_DIV_198_3 ~, (ML99_JUST(66)) +#define ML99_PRIV_DIV_198_6 ~, (ML99_JUST(33)) +#define ML99_PRIV_DIV_198_9 ~, (ML99_JUST(22)) +#define ML99_PRIV_DIV_198_11 ~, (ML99_JUST(18)) +#define ML99_PRIV_DIV_198_18 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_198_22 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_198_33 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_198_66 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_198_99 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_200_2 ~, (ML99_JUST(100)) +#define ML99_PRIV_DIV_200_4 ~, (ML99_JUST(50)) +#define ML99_PRIV_DIV_200_5 ~, (ML99_JUST(40)) +#define ML99_PRIV_DIV_200_8 ~, (ML99_JUST(25)) +#define ML99_PRIV_DIV_200_10 ~, (ML99_JUST(20)) +#define ML99_PRIV_DIV_200_20 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_200_25 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_200_40 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_200_50 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_200_100 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_201_3 ~, (ML99_JUST(67)) +#define ML99_PRIV_DIV_201_67 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_202_2 ~, (ML99_JUST(101)) +#define ML99_PRIV_DIV_202_101 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_203_7 ~, (ML99_JUST(29)) +#define ML99_PRIV_DIV_203_29 ~, (ML99_JUST(7)) + +#define ML99_PRIV_DIV_204_2 ~, (ML99_JUST(102)) +#define ML99_PRIV_DIV_204_3 ~, (ML99_JUST(68)) +#define ML99_PRIV_DIV_204_4 ~, (ML99_JUST(51)) +#define ML99_PRIV_DIV_204_6 ~, (ML99_JUST(34)) +#define ML99_PRIV_DIV_204_12 ~, (ML99_JUST(17)) +#define ML99_PRIV_DIV_204_17 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_204_34 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_204_51 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_204_68 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_204_102 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_205_5 ~, (ML99_JUST(41)) +#define ML99_PRIV_DIV_205_41 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_206_2 ~, (ML99_JUST(103)) +#define ML99_PRIV_DIV_206_103 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_207_3 ~, (ML99_JUST(69)) +#define ML99_PRIV_DIV_207_9 ~, (ML99_JUST(23)) +#define ML99_PRIV_DIV_207_23 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_207_69 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_208_2 ~, (ML99_JUST(104)) +#define ML99_PRIV_DIV_208_4 ~, (ML99_JUST(52)) +#define ML99_PRIV_DIV_208_8 ~, (ML99_JUST(26)) +#define ML99_PRIV_DIV_208_13 ~, (ML99_JUST(16)) +#define ML99_PRIV_DIV_208_16 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_208_26 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_208_52 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_208_104 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_209_11 ~, (ML99_JUST(19)) +#define ML99_PRIV_DIV_209_19 ~, (ML99_JUST(11)) + +#define ML99_PRIV_DIV_210_2 ~, (ML99_JUST(105)) +#define ML99_PRIV_DIV_210_3 ~, (ML99_JUST(70)) +#define ML99_PRIV_DIV_210_5 ~, (ML99_JUST(42)) +#define ML99_PRIV_DIV_210_6 ~, (ML99_JUST(35)) +#define ML99_PRIV_DIV_210_7 ~, (ML99_JUST(30)) +#define ML99_PRIV_DIV_210_10 ~, (ML99_JUST(21)) +#define ML99_PRIV_DIV_210_14 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_210_15 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_210_21 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_210_30 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_210_35 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_210_42 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_210_70 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_210_105 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_212_2 ~, (ML99_JUST(106)) +#define ML99_PRIV_DIV_212_4 ~, (ML99_JUST(53)) +#define ML99_PRIV_DIV_212_53 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_212_106 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_213_3 ~, (ML99_JUST(71)) +#define ML99_PRIV_DIV_213_71 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_214_2 ~, (ML99_JUST(107)) +#define ML99_PRIV_DIV_214_107 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_215_5 ~, (ML99_JUST(43)) +#define ML99_PRIV_DIV_215_43 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_216_2 ~, (ML99_JUST(108)) +#define ML99_PRIV_DIV_216_3 ~, (ML99_JUST(72)) +#define ML99_PRIV_DIV_216_4 ~, (ML99_JUST(54)) +#define ML99_PRIV_DIV_216_6 ~, (ML99_JUST(36)) +#define ML99_PRIV_DIV_216_8 ~, (ML99_JUST(27)) +#define ML99_PRIV_DIV_216_9 ~, (ML99_JUST(24)) +#define ML99_PRIV_DIV_216_12 ~, (ML99_JUST(18)) +#define ML99_PRIV_DIV_216_18 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_216_24 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_216_27 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_216_36 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_216_54 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_216_72 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_216_108 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_217_7 ~, (ML99_JUST(31)) +#define ML99_PRIV_DIV_217_31 ~, (ML99_JUST(7)) + +#define ML99_PRIV_DIV_218_2 ~, (ML99_JUST(109)) +#define ML99_PRIV_DIV_218_109 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_219_3 ~, (ML99_JUST(73)) +#define ML99_PRIV_DIV_219_73 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_220_2 ~, (ML99_JUST(110)) +#define ML99_PRIV_DIV_220_4 ~, (ML99_JUST(55)) +#define ML99_PRIV_DIV_220_5 ~, (ML99_JUST(44)) +#define ML99_PRIV_DIV_220_10 ~, (ML99_JUST(22)) +#define ML99_PRIV_DIV_220_11 ~, (ML99_JUST(20)) +#define ML99_PRIV_DIV_220_20 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_220_22 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_220_44 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_220_55 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_220_110 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_221_13 ~, (ML99_JUST(17)) +#define ML99_PRIV_DIV_221_17 ~, (ML99_JUST(13)) + +#define ML99_PRIV_DIV_222_2 ~, (ML99_JUST(111)) +#define ML99_PRIV_DIV_222_3 ~, (ML99_JUST(74)) +#define ML99_PRIV_DIV_222_6 ~, (ML99_JUST(37)) +#define ML99_PRIV_DIV_222_37 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_222_74 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_222_111 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_224_2 ~, (ML99_JUST(112)) +#define ML99_PRIV_DIV_224_4 ~, (ML99_JUST(56)) +#define ML99_PRIV_DIV_224_7 ~, (ML99_JUST(32)) +#define ML99_PRIV_DIV_224_8 ~, (ML99_JUST(28)) +#define ML99_PRIV_DIV_224_14 ~, (ML99_JUST(16)) +#define ML99_PRIV_DIV_224_16 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_224_28 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_224_32 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_224_56 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_224_112 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_225_3 ~, (ML99_JUST(75)) +#define ML99_PRIV_DIV_225_5 ~, (ML99_JUST(45)) +#define ML99_PRIV_DIV_225_9 ~, (ML99_JUST(25)) +#define ML99_PRIV_DIV_225_15 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_225_25 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_225_45 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_225_75 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_226_2 ~, (ML99_JUST(113)) +#define ML99_PRIV_DIV_226_113 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_228_2 ~, (ML99_JUST(114)) +#define ML99_PRIV_DIV_228_3 ~, (ML99_JUST(76)) +#define ML99_PRIV_DIV_228_4 ~, (ML99_JUST(57)) +#define ML99_PRIV_DIV_228_6 ~, (ML99_JUST(38)) +#define ML99_PRIV_DIV_228_12 ~, (ML99_JUST(19)) +#define ML99_PRIV_DIV_228_19 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_228_38 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_228_57 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_228_76 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_228_114 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_230_2 ~, (ML99_JUST(115)) +#define ML99_PRIV_DIV_230_5 ~, (ML99_JUST(46)) +#define ML99_PRIV_DIV_230_10 ~, (ML99_JUST(23)) +#define ML99_PRIV_DIV_230_23 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_230_46 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_230_115 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_231_3 ~, (ML99_JUST(77)) +#define ML99_PRIV_DIV_231_7 ~, (ML99_JUST(33)) +#define ML99_PRIV_DIV_231_11 ~, (ML99_JUST(21)) +#define ML99_PRIV_DIV_231_21 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_231_33 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_231_77 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_232_2 ~, (ML99_JUST(116)) +#define ML99_PRIV_DIV_232_4 ~, (ML99_JUST(58)) +#define ML99_PRIV_DIV_232_8 ~, (ML99_JUST(29)) +#define ML99_PRIV_DIV_232_29 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_232_58 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_232_116 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_234_2 ~, (ML99_JUST(117)) +#define ML99_PRIV_DIV_234_3 ~, (ML99_JUST(78)) +#define ML99_PRIV_DIV_234_6 ~, (ML99_JUST(39)) +#define ML99_PRIV_DIV_234_9 ~, (ML99_JUST(26)) +#define ML99_PRIV_DIV_234_13 ~, (ML99_JUST(18)) +#define ML99_PRIV_DIV_234_18 ~, (ML99_JUST(13)) +#define ML99_PRIV_DIV_234_26 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_234_39 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_234_78 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_234_117 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_235_5 ~, (ML99_JUST(47)) +#define ML99_PRIV_DIV_235_47 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_236_2 ~, (ML99_JUST(118)) +#define ML99_PRIV_DIV_236_4 ~, (ML99_JUST(59)) +#define ML99_PRIV_DIV_236_59 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_236_118 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_237_3 ~, (ML99_JUST(79)) +#define ML99_PRIV_DIV_237_79 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_238_2 ~, (ML99_JUST(119)) +#define ML99_PRIV_DIV_238_7 ~, (ML99_JUST(34)) +#define ML99_PRIV_DIV_238_14 ~, (ML99_JUST(17)) +#define ML99_PRIV_DIV_238_17 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_238_34 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_238_119 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_240_2 ~, (ML99_JUST(120)) +#define ML99_PRIV_DIV_240_3 ~, (ML99_JUST(80)) +#define ML99_PRIV_DIV_240_4 ~, (ML99_JUST(60)) +#define ML99_PRIV_DIV_240_5 ~, (ML99_JUST(48)) +#define ML99_PRIV_DIV_240_6 ~, (ML99_JUST(40)) +#define ML99_PRIV_DIV_240_8 ~, (ML99_JUST(30)) +#define ML99_PRIV_DIV_240_10 ~, (ML99_JUST(24)) +#define ML99_PRIV_DIV_240_12 ~, (ML99_JUST(20)) +#define ML99_PRIV_DIV_240_15 ~, (ML99_JUST(16)) +#define ML99_PRIV_DIV_240_16 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_240_20 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_240_24 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_240_30 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_240_40 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_240_48 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_240_60 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_240_80 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_240_120 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_242_2 ~, (ML99_JUST(121)) +#define ML99_PRIV_DIV_242_11 ~, (ML99_JUST(22)) +#define ML99_PRIV_DIV_242_22 ~, (ML99_JUST(11)) +#define ML99_PRIV_DIV_242_121 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_243_3 ~, (ML99_JUST(81)) +#define ML99_PRIV_DIV_243_9 ~, (ML99_JUST(27)) +#define ML99_PRIV_DIV_243_27 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_243_81 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_244_2 ~, (ML99_JUST(122)) +#define ML99_PRIV_DIV_244_4 ~, (ML99_JUST(61)) +#define ML99_PRIV_DIV_244_61 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_244_122 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_245_5 ~, (ML99_JUST(49)) +#define ML99_PRIV_DIV_245_7 ~, (ML99_JUST(35)) +#define ML99_PRIV_DIV_245_35 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_245_49 ~, (ML99_JUST(5)) + +#define ML99_PRIV_DIV_246_2 ~, (ML99_JUST(123)) +#define ML99_PRIV_DIV_246_3 ~, (ML99_JUST(82)) +#define ML99_PRIV_DIV_246_6 ~, (ML99_JUST(41)) +#define ML99_PRIV_DIV_246_41 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_246_82 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_246_123 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_247_13 ~, (ML99_JUST(19)) +#define ML99_PRIV_DIV_247_19 ~, (ML99_JUST(13)) + +#define ML99_PRIV_DIV_248_2 ~, (ML99_JUST(124)) +#define ML99_PRIV_DIV_248_4 ~, (ML99_JUST(62)) +#define ML99_PRIV_DIV_248_8 ~, (ML99_JUST(31)) +#define ML99_PRIV_DIV_248_31 ~, (ML99_JUST(8)) +#define ML99_PRIV_DIV_248_62 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_248_124 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_249_3 ~, (ML99_JUST(83)) +#define ML99_PRIV_DIV_249_83 ~, (ML99_JUST(3)) + +#define ML99_PRIV_DIV_250_2 ~, (ML99_JUST(125)) +#define ML99_PRIV_DIV_250_5 ~, (ML99_JUST(50)) +#define ML99_PRIV_DIV_250_10 ~, (ML99_JUST(25)) +#define ML99_PRIV_DIV_250_25 ~, (ML99_JUST(10)) +#define ML99_PRIV_DIV_250_50 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_250_125 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_252_2 ~, (ML99_JUST(126)) +#define ML99_PRIV_DIV_252_3 ~, (ML99_JUST(84)) +#define ML99_PRIV_DIV_252_4 ~, (ML99_JUST(63)) +#define ML99_PRIV_DIV_252_6 ~, (ML99_JUST(42)) +#define ML99_PRIV_DIV_252_7 ~, (ML99_JUST(36)) +#define ML99_PRIV_DIV_252_9 ~, (ML99_JUST(28)) +#define ML99_PRIV_DIV_252_12 ~, (ML99_JUST(21)) +#define ML99_PRIV_DIV_252_14 ~, (ML99_JUST(18)) +#define ML99_PRIV_DIV_252_18 ~, (ML99_JUST(14)) +#define ML99_PRIV_DIV_252_21 ~, (ML99_JUST(12)) +#define ML99_PRIV_DIV_252_28 ~, (ML99_JUST(9)) +#define ML99_PRIV_DIV_252_36 ~, (ML99_JUST(7)) +#define ML99_PRIV_DIV_252_42 ~, (ML99_JUST(6)) +#define ML99_PRIV_DIV_252_63 ~, (ML99_JUST(4)) +#define ML99_PRIV_DIV_252_84 ~, (ML99_JUST(3)) +#define ML99_PRIV_DIV_252_126 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_253_11 ~, (ML99_JUST(23)) +#define ML99_PRIV_DIV_253_23 ~, (ML99_JUST(11)) + +#define ML99_PRIV_DIV_254_2 ~, (ML99_JUST(127)) +#define ML99_PRIV_DIV_254_127 ~, (ML99_JUST(2)) + +#define ML99_PRIV_DIV_255_3 ~, (ML99_JUST(85)) +#define ML99_PRIV_DIV_255_5 ~, (ML99_JUST(51)) +#define ML99_PRIV_DIV_255_15 ~, (ML99_JUST(17)) +#define ML99_PRIV_DIV_255_17 ~, (ML99_JUST(15)) +#define ML99_PRIV_DIV_255_51 ~, (ML99_JUST(5)) +#define ML99_PRIV_DIV_255_85 ~, (ML99_JUST(3)) + +#endif // ML99_NAT_DIV_H diff --git a/test/external/metalang99/include/metalang99/nat/eq.h b/test/external/metalang99/include/metalang99/nat/eq.h new file mode 100644 index 0000000..d4164dd --- /dev/null +++ b/test/external/metalang99/include/metalang99/nat/eq.h @@ -0,0 +1,266 @@ +#ifndef ML99_NAT_EQ_H +#define ML99_NAT_EQ_H + +#include <metalang99/priv/tuple.h> + +#define ML99_PRIV_NAT_EQ(x, y) ML99_PRIV_NAT_EQ_AUX(x, y) +#define ML99_PRIV_NAT_EQ_AUX(x, y) ML99_PRIV_IS_TUPLE_FAST(ML99_PRIV_NAT_EQ_##x##_##y) + +#define ML99_PRIV_NAT_EQ_0_0 () +#define ML99_PRIV_NAT_EQ_1_1 () +#define ML99_PRIV_NAT_EQ_2_2 () +#define ML99_PRIV_NAT_EQ_3_3 () +#define ML99_PRIV_NAT_EQ_4_4 () +#define ML99_PRIV_NAT_EQ_5_5 () +#define ML99_PRIV_NAT_EQ_6_6 () +#define ML99_PRIV_NAT_EQ_7_7 () +#define ML99_PRIV_NAT_EQ_8_8 () +#define ML99_PRIV_NAT_EQ_9_9 () +#define ML99_PRIV_NAT_EQ_10_10 () +#define ML99_PRIV_NAT_EQ_11_11 () +#define ML99_PRIV_NAT_EQ_12_12 () +#define ML99_PRIV_NAT_EQ_13_13 () +#define ML99_PRIV_NAT_EQ_14_14 () +#define ML99_PRIV_NAT_EQ_15_15 () +#define ML99_PRIV_NAT_EQ_16_16 () +#define ML99_PRIV_NAT_EQ_17_17 () +#define ML99_PRIV_NAT_EQ_18_18 () +#define ML99_PRIV_NAT_EQ_19_19 () +#define ML99_PRIV_NAT_EQ_20_20 () +#define ML99_PRIV_NAT_EQ_21_21 () +#define ML99_PRIV_NAT_EQ_22_22 () +#define ML99_PRIV_NAT_EQ_23_23 () +#define ML99_PRIV_NAT_EQ_24_24 () +#define ML99_PRIV_NAT_EQ_25_25 () +#define ML99_PRIV_NAT_EQ_26_26 () +#define ML99_PRIV_NAT_EQ_27_27 () +#define ML99_PRIV_NAT_EQ_28_28 () +#define ML99_PRIV_NAT_EQ_29_29 () +#define ML99_PRIV_NAT_EQ_30_30 () +#define ML99_PRIV_NAT_EQ_31_31 () +#define ML99_PRIV_NAT_EQ_32_32 () +#define ML99_PRIV_NAT_EQ_33_33 () +#define ML99_PRIV_NAT_EQ_34_34 () +#define ML99_PRIV_NAT_EQ_35_35 () +#define ML99_PRIV_NAT_EQ_36_36 () +#define ML99_PRIV_NAT_EQ_37_37 () +#define ML99_PRIV_NAT_EQ_38_38 () +#define ML99_PRIV_NAT_EQ_39_39 () +#define ML99_PRIV_NAT_EQ_40_40 () +#define ML99_PRIV_NAT_EQ_41_41 () +#define ML99_PRIV_NAT_EQ_42_42 () +#define ML99_PRIV_NAT_EQ_43_43 () +#define ML99_PRIV_NAT_EQ_44_44 () +#define ML99_PRIV_NAT_EQ_45_45 () +#define ML99_PRIV_NAT_EQ_46_46 () +#define ML99_PRIV_NAT_EQ_47_47 () +#define ML99_PRIV_NAT_EQ_48_48 () +#define ML99_PRIV_NAT_EQ_49_49 () +#define ML99_PRIV_NAT_EQ_50_50 () +#define ML99_PRIV_NAT_EQ_51_51 () +#define ML99_PRIV_NAT_EQ_52_52 () +#define ML99_PRIV_NAT_EQ_53_53 () +#define ML99_PRIV_NAT_EQ_54_54 () +#define ML99_PRIV_NAT_EQ_55_55 () +#define ML99_PRIV_NAT_EQ_56_56 () +#define ML99_PRIV_NAT_EQ_57_57 () +#define ML99_PRIV_NAT_EQ_58_58 () +#define ML99_PRIV_NAT_EQ_59_59 () +#define ML99_PRIV_NAT_EQ_60_60 () +#define ML99_PRIV_NAT_EQ_61_61 () +#define ML99_PRIV_NAT_EQ_62_62 () +#define ML99_PRIV_NAT_EQ_63_63 () +#define ML99_PRIV_NAT_EQ_64_64 () +#define ML99_PRIV_NAT_EQ_65_65 () +#define ML99_PRIV_NAT_EQ_66_66 () +#define ML99_PRIV_NAT_EQ_67_67 () +#define ML99_PRIV_NAT_EQ_68_68 () +#define ML99_PRIV_NAT_EQ_69_69 () +#define ML99_PRIV_NAT_EQ_70_70 () +#define ML99_PRIV_NAT_EQ_71_71 () +#define ML99_PRIV_NAT_EQ_72_72 () +#define ML99_PRIV_NAT_EQ_73_73 () +#define ML99_PRIV_NAT_EQ_74_74 () +#define ML99_PRIV_NAT_EQ_75_75 () +#define ML99_PRIV_NAT_EQ_76_76 () +#define ML99_PRIV_NAT_EQ_77_77 () +#define ML99_PRIV_NAT_EQ_78_78 () +#define ML99_PRIV_NAT_EQ_79_79 () +#define ML99_PRIV_NAT_EQ_80_80 () +#define ML99_PRIV_NAT_EQ_81_81 () +#define ML99_PRIV_NAT_EQ_82_82 () +#define ML99_PRIV_NAT_EQ_83_83 () +#define ML99_PRIV_NAT_EQ_84_84 () +#define ML99_PRIV_NAT_EQ_85_85 () +#define ML99_PRIV_NAT_EQ_86_86 () +#define ML99_PRIV_NAT_EQ_87_87 () +#define ML99_PRIV_NAT_EQ_88_88 () +#define ML99_PRIV_NAT_EQ_89_89 () +#define ML99_PRIV_NAT_EQ_90_90 () +#define ML99_PRIV_NAT_EQ_91_91 () +#define ML99_PRIV_NAT_EQ_92_92 () +#define ML99_PRIV_NAT_EQ_93_93 () +#define ML99_PRIV_NAT_EQ_94_94 () +#define ML99_PRIV_NAT_EQ_95_95 () +#define ML99_PRIV_NAT_EQ_96_96 () +#define ML99_PRIV_NAT_EQ_97_97 () +#define ML99_PRIV_NAT_EQ_98_98 () +#define ML99_PRIV_NAT_EQ_99_99 () +#define ML99_PRIV_NAT_EQ_100_100 () +#define ML99_PRIV_NAT_EQ_101_101 () +#define ML99_PRIV_NAT_EQ_102_102 () +#define ML99_PRIV_NAT_EQ_103_103 () +#define ML99_PRIV_NAT_EQ_104_104 () +#define ML99_PRIV_NAT_EQ_105_105 () +#define ML99_PRIV_NAT_EQ_106_106 () +#define ML99_PRIV_NAT_EQ_107_107 () +#define ML99_PRIV_NAT_EQ_108_108 () +#define ML99_PRIV_NAT_EQ_109_109 () +#define ML99_PRIV_NAT_EQ_110_110 () +#define ML99_PRIV_NAT_EQ_111_111 () +#define ML99_PRIV_NAT_EQ_112_112 () +#define ML99_PRIV_NAT_EQ_113_113 () +#define ML99_PRIV_NAT_EQ_114_114 () +#define ML99_PRIV_NAT_EQ_115_115 () +#define ML99_PRIV_NAT_EQ_116_116 () +#define ML99_PRIV_NAT_EQ_117_117 () +#define ML99_PRIV_NAT_EQ_118_118 () +#define ML99_PRIV_NAT_EQ_119_119 () +#define ML99_PRIV_NAT_EQ_120_120 () +#define ML99_PRIV_NAT_EQ_121_121 () +#define ML99_PRIV_NAT_EQ_122_122 () +#define ML99_PRIV_NAT_EQ_123_123 () +#define ML99_PRIV_NAT_EQ_124_124 () +#define ML99_PRIV_NAT_EQ_125_125 () +#define ML99_PRIV_NAT_EQ_126_126 () +#define ML99_PRIV_NAT_EQ_127_127 () +#define ML99_PRIV_NAT_EQ_128_128 () +#define ML99_PRIV_NAT_EQ_129_129 () +#define ML99_PRIV_NAT_EQ_130_130 () +#define ML99_PRIV_NAT_EQ_131_131 () +#define ML99_PRIV_NAT_EQ_132_132 () +#define ML99_PRIV_NAT_EQ_133_133 () +#define ML99_PRIV_NAT_EQ_134_134 () +#define ML99_PRIV_NAT_EQ_135_135 () +#define ML99_PRIV_NAT_EQ_136_136 () +#define ML99_PRIV_NAT_EQ_137_137 () +#define ML99_PRIV_NAT_EQ_138_138 () +#define ML99_PRIV_NAT_EQ_139_139 () +#define ML99_PRIV_NAT_EQ_140_140 () +#define ML99_PRIV_NAT_EQ_141_141 () +#define ML99_PRIV_NAT_EQ_142_142 () +#define ML99_PRIV_NAT_EQ_143_143 () +#define ML99_PRIV_NAT_EQ_144_144 () +#define ML99_PRIV_NAT_EQ_145_145 () +#define ML99_PRIV_NAT_EQ_146_146 () +#define ML99_PRIV_NAT_EQ_147_147 () +#define ML99_PRIV_NAT_EQ_148_148 () +#define ML99_PRIV_NAT_EQ_149_149 () +#define ML99_PRIV_NAT_EQ_150_150 () +#define ML99_PRIV_NAT_EQ_151_151 () +#define ML99_PRIV_NAT_EQ_152_152 () +#define ML99_PRIV_NAT_EQ_153_153 () +#define ML99_PRIV_NAT_EQ_154_154 () +#define ML99_PRIV_NAT_EQ_155_155 () +#define ML99_PRIV_NAT_EQ_156_156 () +#define ML99_PRIV_NAT_EQ_157_157 () +#define ML99_PRIV_NAT_EQ_158_158 () +#define ML99_PRIV_NAT_EQ_159_159 () +#define ML99_PRIV_NAT_EQ_160_160 () +#define ML99_PRIV_NAT_EQ_161_161 () +#define ML99_PRIV_NAT_EQ_162_162 () +#define ML99_PRIV_NAT_EQ_163_163 () +#define ML99_PRIV_NAT_EQ_164_164 () +#define ML99_PRIV_NAT_EQ_165_165 () +#define ML99_PRIV_NAT_EQ_166_166 () +#define ML99_PRIV_NAT_EQ_167_167 () +#define ML99_PRIV_NAT_EQ_168_168 () +#define ML99_PRIV_NAT_EQ_169_169 () +#define ML99_PRIV_NAT_EQ_170_170 () +#define ML99_PRIV_NAT_EQ_171_171 () +#define ML99_PRIV_NAT_EQ_172_172 () +#define ML99_PRIV_NAT_EQ_173_173 () +#define ML99_PRIV_NAT_EQ_174_174 () +#define ML99_PRIV_NAT_EQ_175_175 () +#define ML99_PRIV_NAT_EQ_176_176 () +#define ML99_PRIV_NAT_EQ_177_177 () +#define ML99_PRIV_NAT_EQ_178_178 () +#define ML99_PRIV_NAT_EQ_179_179 () +#define ML99_PRIV_NAT_EQ_180_180 () +#define ML99_PRIV_NAT_EQ_181_181 () +#define ML99_PRIV_NAT_EQ_182_182 () +#define ML99_PRIV_NAT_EQ_183_183 () +#define ML99_PRIV_NAT_EQ_184_184 () +#define ML99_PRIV_NAT_EQ_185_185 () +#define ML99_PRIV_NAT_EQ_186_186 () +#define ML99_PRIV_NAT_EQ_187_187 () +#define ML99_PRIV_NAT_EQ_188_188 () +#define ML99_PRIV_NAT_EQ_189_189 () +#define ML99_PRIV_NAT_EQ_190_190 () +#define ML99_PRIV_NAT_EQ_191_191 () +#define ML99_PRIV_NAT_EQ_192_192 () +#define ML99_PRIV_NAT_EQ_193_193 () +#define ML99_PRIV_NAT_EQ_194_194 () +#define ML99_PRIV_NAT_EQ_195_195 () +#define ML99_PRIV_NAT_EQ_196_196 () +#define ML99_PRIV_NAT_EQ_197_197 () +#define ML99_PRIV_NAT_EQ_198_198 () +#define ML99_PRIV_NAT_EQ_199_199 () +#define ML99_PRIV_NAT_EQ_200_200 () +#define ML99_PRIV_NAT_EQ_201_201 () +#define ML99_PRIV_NAT_EQ_202_202 () +#define ML99_PRIV_NAT_EQ_203_203 () +#define ML99_PRIV_NAT_EQ_204_204 () +#define ML99_PRIV_NAT_EQ_205_205 () +#define ML99_PRIV_NAT_EQ_206_206 () +#define ML99_PRIV_NAT_EQ_207_207 () +#define ML99_PRIV_NAT_EQ_208_208 () +#define ML99_PRIV_NAT_EQ_209_209 () +#define ML99_PRIV_NAT_EQ_210_210 () +#define ML99_PRIV_NAT_EQ_211_211 () +#define ML99_PRIV_NAT_EQ_212_212 () +#define ML99_PRIV_NAT_EQ_213_213 () +#define ML99_PRIV_NAT_EQ_214_214 () +#define ML99_PRIV_NAT_EQ_215_215 () +#define ML99_PRIV_NAT_EQ_216_216 () +#define ML99_PRIV_NAT_EQ_217_217 () +#define ML99_PRIV_NAT_EQ_218_218 () +#define ML99_PRIV_NAT_EQ_219_219 () +#define ML99_PRIV_NAT_EQ_220_220 () +#define ML99_PRIV_NAT_EQ_221_221 () +#define ML99_PRIV_NAT_EQ_222_222 () +#define ML99_PRIV_NAT_EQ_223_223 () +#define ML99_PRIV_NAT_EQ_224_224 () +#define ML99_PRIV_NAT_EQ_225_225 () +#define ML99_PRIV_NAT_EQ_226_226 () +#define ML99_PRIV_NAT_EQ_227_227 () +#define ML99_PRIV_NAT_EQ_228_228 () +#define ML99_PRIV_NAT_EQ_229_229 () +#define ML99_PRIV_NAT_EQ_230_230 () +#define ML99_PRIV_NAT_EQ_231_231 () +#define ML99_PRIV_NAT_EQ_232_232 () +#define ML99_PRIV_NAT_EQ_233_233 () +#define ML99_PRIV_NAT_EQ_234_234 () +#define ML99_PRIV_NAT_EQ_235_235 () +#define ML99_PRIV_NAT_EQ_236_236 () +#define ML99_PRIV_NAT_EQ_237_237 () +#define ML99_PRIV_NAT_EQ_238_238 () +#define ML99_PRIV_NAT_EQ_239_239 () +#define ML99_PRIV_NAT_EQ_240_240 () +#define ML99_PRIV_NAT_EQ_241_241 () +#define ML99_PRIV_NAT_EQ_242_242 () +#define ML99_PRIV_NAT_EQ_243_243 () +#define ML99_PRIV_NAT_EQ_244_244 () +#define ML99_PRIV_NAT_EQ_245_245 () +#define ML99_PRIV_NAT_EQ_246_246 () +#define ML99_PRIV_NAT_EQ_247_247 () +#define ML99_PRIV_NAT_EQ_248_248 () +#define ML99_PRIV_NAT_EQ_249_249 () +#define ML99_PRIV_NAT_EQ_250_250 () +#define ML99_PRIV_NAT_EQ_251_251 () +#define ML99_PRIV_NAT_EQ_252_252 () +#define ML99_PRIV_NAT_EQ_253_253 () +#define ML99_PRIV_NAT_EQ_254_254 () +#define ML99_PRIV_NAT_EQ_255_255 () + +#endif // ML99_NAT_EQ_H diff --git a/test/external/metalang99/include/metalang99/nat/inc.h b/test/external/metalang99/include/metalang99/nat/inc.h new file mode 100644 index 0000000..1543900 --- /dev/null +++ b/test/external/metalang99/include/metalang99/nat/inc.h @@ -0,0 +1,264 @@ +#ifndef ML99_NAT_INC_H +#define ML99_NAT_INC_H + +#define ML99_PRIV_INC(x) ML99_PRIV_INC_AUX(x) +#define ML99_PRIV_INC_AUX(x) ML99_PRIV_INC_##x + +#define ML99_PRIV_INC_0 1 +#define ML99_PRIV_INC_1 2 +#define ML99_PRIV_INC_2 3 +#define ML99_PRIV_INC_3 4 +#define ML99_PRIV_INC_4 5 +#define ML99_PRIV_INC_5 6 +#define ML99_PRIV_INC_6 7 +#define ML99_PRIV_INC_7 8 +#define ML99_PRIV_INC_8 9 +#define ML99_PRIV_INC_9 10 +#define ML99_PRIV_INC_10 11 +#define ML99_PRIV_INC_11 12 +#define ML99_PRIV_INC_12 13 +#define ML99_PRIV_INC_13 14 +#define ML99_PRIV_INC_14 15 +#define ML99_PRIV_INC_15 16 +#define ML99_PRIV_INC_16 17 +#define ML99_PRIV_INC_17 18 +#define ML99_PRIV_INC_18 19 +#define ML99_PRIV_INC_19 20 +#define ML99_PRIV_INC_20 21 +#define ML99_PRIV_INC_21 22 +#define ML99_PRIV_INC_22 23 +#define ML99_PRIV_INC_23 24 +#define ML99_PRIV_INC_24 25 +#define ML99_PRIV_INC_25 26 +#define ML99_PRIV_INC_26 27 +#define ML99_PRIV_INC_27 28 +#define ML99_PRIV_INC_28 29 +#define ML99_PRIV_INC_29 30 +#define ML99_PRIV_INC_30 31 +#define ML99_PRIV_INC_31 32 +#define ML99_PRIV_INC_32 33 +#define ML99_PRIV_INC_33 34 +#define ML99_PRIV_INC_34 35 +#define ML99_PRIV_INC_35 36 +#define ML99_PRIV_INC_36 37 +#define ML99_PRIV_INC_37 38 +#define ML99_PRIV_INC_38 39 +#define ML99_PRIV_INC_39 40 +#define ML99_PRIV_INC_40 41 +#define ML99_PRIV_INC_41 42 +#define ML99_PRIV_INC_42 43 +#define ML99_PRIV_INC_43 44 +#define ML99_PRIV_INC_44 45 +#define ML99_PRIV_INC_45 46 +#define ML99_PRIV_INC_46 47 +#define ML99_PRIV_INC_47 48 +#define ML99_PRIV_INC_48 49 +#define ML99_PRIV_INC_49 50 +#define ML99_PRIV_INC_50 51 +#define ML99_PRIV_INC_51 52 +#define ML99_PRIV_INC_52 53 +#define ML99_PRIV_INC_53 54 +#define ML99_PRIV_INC_54 55 +#define ML99_PRIV_INC_55 56 +#define ML99_PRIV_INC_56 57 +#define ML99_PRIV_INC_57 58 +#define ML99_PRIV_INC_58 59 +#define ML99_PRIV_INC_59 60 +#define ML99_PRIV_INC_60 61 +#define ML99_PRIV_INC_61 62 +#define ML99_PRIV_INC_62 63 +#define ML99_PRIV_INC_63 64 +#define ML99_PRIV_INC_64 65 +#define ML99_PRIV_INC_65 66 +#define ML99_PRIV_INC_66 67 +#define ML99_PRIV_INC_67 68 +#define ML99_PRIV_INC_68 69 +#define ML99_PRIV_INC_69 70 +#define ML99_PRIV_INC_70 71 +#define ML99_PRIV_INC_71 72 +#define ML99_PRIV_INC_72 73 +#define ML99_PRIV_INC_73 74 +#define ML99_PRIV_INC_74 75 +#define ML99_PRIV_INC_75 76 +#define ML99_PRIV_INC_76 77 +#define ML99_PRIV_INC_77 78 +#define ML99_PRIV_INC_78 79 +#define ML99_PRIV_INC_79 80 +#define ML99_PRIV_INC_80 81 +#define ML99_PRIV_INC_81 82 +#define ML99_PRIV_INC_82 83 +#define ML99_PRIV_INC_83 84 +#define ML99_PRIV_INC_84 85 +#define ML99_PRIV_INC_85 86 +#define ML99_PRIV_INC_86 87 +#define ML99_PRIV_INC_87 88 +#define ML99_PRIV_INC_88 89 +#define ML99_PRIV_INC_89 90 +#define ML99_PRIV_INC_90 91 +#define ML99_PRIV_INC_91 92 +#define ML99_PRIV_INC_92 93 +#define ML99_PRIV_INC_93 94 +#define ML99_PRIV_INC_94 95 +#define ML99_PRIV_INC_95 96 +#define ML99_PRIV_INC_96 97 +#define ML99_PRIV_INC_97 98 +#define ML99_PRIV_INC_98 99 +#define ML99_PRIV_INC_99 100 +#define ML99_PRIV_INC_100 101 +#define ML99_PRIV_INC_101 102 +#define ML99_PRIV_INC_102 103 +#define ML99_PRIV_INC_103 104 +#define ML99_PRIV_INC_104 105 +#define ML99_PRIV_INC_105 106 +#define ML99_PRIV_INC_106 107 +#define ML99_PRIV_INC_107 108 +#define ML99_PRIV_INC_108 109 +#define ML99_PRIV_INC_109 110 +#define ML99_PRIV_INC_110 111 +#define ML99_PRIV_INC_111 112 +#define ML99_PRIV_INC_112 113 +#define ML99_PRIV_INC_113 114 +#define ML99_PRIV_INC_114 115 +#define ML99_PRIV_INC_115 116 +#define ML99_PRIV_INC_116 117 +#define ML99_PRIV_INC_117 118 +#define ML99_PRIV_INC_118 119 +#define ML99_PRIV_INC_119 120 +#define ML99_PRIV_INC_120 121 +#define ML99_PRIV_INC_121 122 +#define ML99_PRIV_INC_122 123 +#define ML99_PRIV_INC_123 124 +#define ML99_PRIV_INC_124 125 +#define ML99_PRIV_INC_125 126 +#define ML99_PRIV_INC_126 127 +#define ML99_PRIV_INC_127 128 +#define ML99_PRIV_INC_128 129 +#define ML99_PRIV_INC_129 130 +#define ML99_PRIV_INC_130 131 +#define ML99_PRIV_INC_131 132 +#define ML99_PRIV_INC_132 133 +#define ML99_PRIV_INC_133 134 +#define ML99_PRIV_INC_134 135 +#define ML99_PRIV_INC_135 136 +#define ML99_PRIV_INC_136 137 +#define ML99_PRIV_INC_137 138 +#define ML99_PRIV_INC_138 139 +#define ML99_PRIV_INC_139 140 +#define ML99_PRIV_INC_140 141 +#define ML99_PRIV_INC_141 142 +#define ML99_PRIV_INC_142 143 +#define ML99_PRIV_INC_143 144 +#define ML99_PRIV_INC_144 145 +#define ML99_PRIV_INC_145 146 +#define ML99_PRIV_INC_146 147 +#define ML99_PRIV_INC_147 148 +#define ML99_PRIV_INC_148 149 +#define ML99_PRIV_INC_149 150 +#define ML99_PRIV_INC_150 151 +#define ML99_PRIV_INC_151 152 +#define ML99_PRIV_INC_152 153 +#define ML99_PRIV_INC_153 154 +#define ML99_PRIV_INC_154 155 +#define ML99_PRIV_INC_155 156 +#define ML99_PRIV_INC_156 157 +#define ML99_PRIV_INC_157 158 +#define ML99_PRIV_INC_158 159 +#define ML99_PRIV_INC_159 160 +#define ML99_PRIV_INC_160 161 +#define ML99_PRIV_INC_161 162 +#define ML99_PRIV_INC_162 163 +#define ML99_PRIV_INC_163 164 +#define ML99_PRIV_INC_164 165 +#define ML99_PRIV_INC_165 166 +#define ML99_PRIV_INC_166 167 +#define ML99_PRIV_INC_167 168 +#define ML99_PRIV_INC_168 169 +#define ML99_PRIV_INC_169 170 +#define ML99_PRIV_INC_170 171 +#define ML99_PRIV_INC_171 172 +#define ML99_PRIV_INC_172 173 +#define ML99_PRIV_INC_173 174 +#define ML99_PRIV_INC_174 175 +#define ML99_PRIV_INC_175 176 +#define ML99_PRIV_INC_176 177 +#define ML99_PRIV_INC_177 178 +#define ML99_PRIV_INC_178 179 +#define ML99_PRIV_INC_179 180 +#define ML99_PRIV_INC_180 181 +#define ML99_PRIV_INC_181 182 +#define ML99_PRIV_INC_182 183 +#define ML99_PRIV_INC_183 184 +#define ML99_PRIV_INC_184 185 +#define ML99_PRIV_INC_185 186 +#define ML99_PRIV_INC_186 187 +#define ML99_PRIV_INC_187 188 +#define ML99_PRIV_INC_188 189 +#define ML99_PRIV_INC_189 190 +#define ML99_PRIV_INC_190 191 +#define ML99_PRIV_INC_191 192 +#define ML99_PRIV_INC_192 193 +#define ML99_PRIV_INC_193 194 +#define ML99_PRIV_INC_194 195 +#define ML99_PRIV_INC_195 196 +#define ML99_PRIV_INC_196 197 +#define ML99_PRIV_INC_197 198 +#define ML99_PRIV_INC_198 199 +#define ML99_PRIV_INC_199 200 +#define ML99_PRIV_INC_200 201 +#define ML99_PRIV_INC_201 202 +#define ML99_PRIV_INC_202 203 +#define ML99_PRIV_INC_203 204 +#define ML99_PRIV_INC_204 205 +#define ML99_PRIV_INC_205 206 +#define ML99_PRIV_INC_206 207 +#define ML99_PRIV_INC_207 208 +#define ML99_PRIV_INC_208 209 +#define ML99_PRIV_INC_209 210 +#define ML99_PRIV_INC_210 211 +#define ML99_PRIV_INC_211 212 +#define ML99_PRIV_INC_212 213 +#define ML99_PRIV_INC_213 214 +#define ML99_PRIV_INC_214 215 +#define ML99_PRIV_INC_215 216 +#define ML99_PRIV_INC_216 217 +#define ML99_PRIV_INC_217 218 +#define ML99_PRIV_INC_218 219 +#define ML99_PRIV_INC_219 220 +#define ML99_PRIV_INC_220 221 +#define ML99_PRIV_INC_221 222 +#define ML99_PRIV_INC_222 223 +#define ML99_PRIV_INC_223 224 +#define ML99_PRIV_INC_224 225 +#define ML99_PRIV_INC_225 226 +#define ML99_PRIV_INC_226 227 +#define ML99_PRIV_INC_227 228 +#define ML99_PRIV_INC_228 229 +#define ML99_PRIV_INC_229 230 +#define ML99_PRIV_INC_230 231 +#define ML99_PRIV_INC_231 232 +#define ML99_PRIV_INC_232 233 +#define ML99_PRIV_INC_233 234 +#define ML99_PRIV_INC_234 235 +#define ML99_PRIV_INC_235 236 +#define ML99_PRIV_INC_236 237 +#define ML99_PRIV_INC_237 238 +#define ML99_PRIV_INC_238 239 +#define ML99_PRIV_INC_239 240 +#define ML99_PRIV_INC_240 241 +#define ML99_PRIV_INC_241 242 +#define ML99_PRIV_INC_242 243 +#define ML99_PRIV_INC_243 244 +#define ML99_PRIV_INC_244 245 +#define ML99_PRIV_INC_245 246 +#define ML99_PRIV_INC_246 247 +#define ML99_PRIV_INC_247 248 +#define ML99_PRIV_INC_248 249 +#define ML99_PRIV_INC_249 250 +#define ML99_PRIV_INC_250 251 +#define ML99_PRIV_INC_251 252 +#define ML99_PRIV_INC_252 253 +#define ML99_PRIV_INC_253 254 +#define ML99_PRIV_INC_254 255 +#define ML99_PRIV_INC_255 0 + +#endif // ML99_NAT_INC_H diff --git a/test/external/metalang99/include/metalang99/priv/bool.h b/test/external/metalang99/include/metalang99/priv/bool.h new file mode 100644 index 0000000..d0b19d2 --- /dev/null +++ b/test/external/metalang99/include/metalang99/priv/bool.h @@ -0,0 +1,46 @@ +#ifndef ML99_PRIV_BOOL_H +#define ML99_PRIV_BOOL_H + +#define ML99_PRIV_TRUE(...) 1 +#define ML99_PRIV_FALSE(...) 0 + +#define ML99_PRIV_NOT(b) ML99_PRIV_LOGICAL_OVERLOAD_SINGLE(ML99_PRIV_NOT_, b) +#define ML99_PRIV_NOT_0 1 +#define ML99_PRIV_NOT_1 0 + +#define ML99_PRIV_AND(x, y) ML99_PRIV_LOGICAL_OVERLOAD(ML99_PRIV_AND_, x, y) +#define ML99_PRIV_AND_00 0 +#define ML99_PRIV_AND_01 0 +#define ML99_PRIV_AND_10 0 +#define ML99_PRIV_AND_11 1 + +#define ML99_PRIV_OR(x, y) ML99_PRIV_LOGICAL_OVERLOAD(ML99_PRIV_OR_, x, y) +#define ML99_PRIV_OR_00 0 +#define ML99_PRIV_OR_01 1 +#define ML99_PRIV_OR_10 1 +#define ML99_PRIV_OR_11 1 + +#define ML99_PRIV_OR3(a, b, c) ML99_PRIV_OR(a, ML99_PRIV_OR(b, c)) +#define ML99_PRIV_OR4(a, b, c, d) ML99_PRIV_OR3(a, b, ML99_PRIV_OR(c, d)) + +#define ML99_PRIV_XOR(x, y) ML99_PRIV_LOGICAL_OVERLOAD(ML99_PRIV_XOR_, x, y) +#define ML99_PRIV_XOR_00 0 +#define ML99_PRIV_XOR_01 1 +#define ML99_PRIV_XOR_10 1 +#define ML99_PRIV_XOR_11 0 + +#define ML99_PRIV_BOOL_EQ(x, y) ML99_PRIV_LOGICAL_OVERLOAD(ML99_PRIV_BOOL_EQ_, x, y) +#define ML99_PRIV_BOOL_EQ_00 1 +#define ML99_PRIV_BOOL_EQ_01 0 +#define ML99_PRIV_BOOL_EQ_10 0 +#define ML99_PRIV_BOOL_EQ_11 1 + +#define ML99_PRIV_LOGICAL_OVERLOAD(op, x, y) op##x##y +#define ML99_PRIV_LOGICAL_OVERLOAD_SINGLE(op, b) op##b + +#define ML99_PRIV_IF(cond, x, y) ML99_PRIV_IF_OVERLOAD(cond)(x, y) +#define ML99_PRIV_IF_OVERLOAD(cond) ML99_PRIV_IF_##cond +#define ML99_PRIV_IF_0(_x, y) y +#define ML99_PRIV_IF_1(x, _y) x + +#endif // ML99_PRIV_BOOL_H diff --git a/test/external/metalang99/include/metalang99/priv/compiler_specific.h b/test/external/metalang99/include/metalang99/priv/compiler_specific.h new file mode 100644 index 0000000..c334e21 --- /dev/null +++ b/test/external/metalang99/include/metalang99/priv/compiler_specific.h @@ -0,0 +1,69 @@ +#ifndef ML99_PRIV_COMPILER_SPECIFIC_H +#define ML99_PRIV_COMPILER_SPECIFIC_H + +#define ML99_PRIV_C11_VERSION 201112L + +// GCC 4.6 Release Series: <https://gcc.gnu.org/gcc-4.6/changes.html>. +#define ML99_PRIV_IS_GCC_4_6_OR_HIGHER ((__GNUC__ == 4 && __GNUC_MINOR__ >= 6) || (__GNUC__ >= 5)) + +#ifdef __GNUC__ +#define ML99_PRIV_COMPILER_ATTR_UNUSED __attribute__((unused)) +#else +#define ML99_PRIV_COMPILER_ATTR_UNUSED +#endif + +// ML99_PRIV_C11_STATIC_ASSERT_AVAILABLE { + +#if __STDC__ && __STDC_VERSION__ >= ML99_PRIV_C11_VERSION + +#define ML99_PRIV_C11_STATIC_ASSERT_AVAILABLE + +/* + * On MSVC, `__STDC__` expands to 0 if the `\Za` option was not specified, but the thing is that it + * nevertheless supports C11's `_Static_assert`. + * + * MSVC Standard predefined macros: + * <https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros#standard-predefined-macros>. + */ +#elif defined(_MSC_VER) && __STDC_VERSION__ >= ML99_PRIV_C11_VERSION +#define ML99_PRIV_C11_STATIC_ASSERT_AVAILABLE +#endif +// } (ML99_PRIV_C11_STATIC_ASSERT_AVAILABLE) + +// ML99_PRIV_EMIT_ERROR { + +#ifdef ML99_PRIV_C11_STATIC_ASSERT_AVAILABLE +#define ML99_PRIV_EMIT_ERROR ML99_PRIV_STATIC_ASSERT_ERROR +#elif defined(__clang__) + +#if __has_extension(c_static_assert) +#define ML99_PRIV_EMIT_ERROR ML99_PRIV_STATIC_ASSERT_ERROR +#endif + +#elif defined(__GNUC__) + +#if ML99_PRIV_IS_GCC_4_6_OR_HIGHER +#define ML99_PRIV_EMIT_ERROR ML99_PRIV_STATIC_ASSERT_ERROR +#else + +// GCC Common Function Attributes: +// <https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html>. +#define ML99_PRIV_EMIT_ERROR(message) \ + void __attribute__((constructor, error(message))) ML99_CAT(ml99_error_, __LINE__)(void) { \ + ML99_CAT(ml99_error_, __LINE__)(); \ + } + +#endif + +#endif + +#if !defined(ML99_PRIV_EMIT_ERROR) && !defined(ML99_ALLOW_POOR_DIAGNOSTICS) +#error Your compiler doesn't support decent diagnostic messages. \ +You'll have to search for Metalang99 errors in a preprocessed-only file (-E) by yourself. \ +Define ML99_ALLOW_POOR_DIAGNOSTICS to suppress this error. +#endif + +#define ML99_PRIV_STATIC_ASSERT_ERROR(message) _Static_assert(0, message) +// } (ML99_PRIV_EMIT_ERROR) + +#endif // ML99_PRIV_COMPILER_SPECIFIC_H diff --git a/test/external/metalang99/include/metalang99/priv/tuple.h b/test/external/metalang99/include/metalang99/priv/tuple.h new file mode 100644 index 0000000..ea2fd19 --- /dev/null +++ b/test/external/metalang99/include/metalang99/priv/tuple.h @@ -0,0 +1,33 @@ +#ifndef ML99_PRIV_TUPLE_H +#define ML99_PRIV_TUPLE_H + +#include <metalang99/priv/bool.h> +#include <metalang99/priv/util.h> + +#define ML99_PRIV_IS_TUPLE(x) ML99_PRIV_NOT(ML99_PRIV_IS_UNTUPLE(x)) +#define ML99_PRIV_IS_TUPLE_FAST(x) ML99_PRIV_NOT(ML99_PRIV_IS_UNTUPLE_FAST(x)) + +#define ML99_PRIV_IS_UNTUPLE(x) \ + ML99_PRIV_IF( \ + ML99_PRIV_IS_DOUBLE_TUPLE_BEGINNING(x), \ + ML99_PRIV_TRUE, \ + ML99_PRIV_IS_UNTUPLE_FAST) \ + (x) + +#define ML99_PRIV_IS_UNTUPLE_FAST(x) ML99_PRIV_SND(ML99_PRIV_IS_UNTUPLE_FAST_TEST x, 1) +#define ML99_PRIV_IS_UNTUPLE_FAST_TEST(...) ~, 0 + +#define ML99_PRIV_UNTUPLE(x) ML99_PRIV_EXPAND x + +/** + * Checks whether @p x takes the form `(...) (...) ...`. + * + * This often happens when you miss a comma between items: + * - `v(123) v(456)` + * - `(Foo, int) (Bar, int)` (as in Datatype99) + * - etc. + */ +#define ML99_PRIV_IS_DOUBLE_TUPLE_BEGINNING(x) \ + ML99_PRIV_CONTAINS_COMMA(ML99_PRIV_EXPAND(ML99_PRIV_COMMA ML99_PRIV_EMPTY x)) + +#endif // ML99_PRIV_TUPLE_H diff --git a/test/external/metalang99/include/metalang99/priv/util.h b/test/external/metalang99/include/metalang99/priv/util.h new file mode 100644 index 0000000..80a5bc4 --- /dev/null +++ b/test/external/metalang99/include/metalang99/priv/util.h @@ -0,0 +1,27 @@ +#ifndef ML99_PRIV_UTIL_H +#define ML99_PRIV_UTIL_H + +#define ML99_PRIV_CAT(x, y) ML99_PRIV_PRIMITIVE_CAT(x, y) +#define ML99_PRIV_PRIMITIVE_CAT(x, y) x##y + +#define ML99_PRIV_CAT3(x, y, z) ML99_PRIV_PRIMITIVE_CAT3(x, y, z) +#define ML99_PRIV_PRIMITIVE_CAT3(x, y, z) x##y##z + +#define ML99_PRIV_EXPAND(...) __VA_ARGS__ +#define ML99_PRIV_EMPTY(...) +#define ML99_PRIV_COMMA(...) , + +#define ML99_PRIV_HEAD(...) ML99_PRIV_HEAD_AUX(__VA_ARGS__, ~) +#define ML99_PRIV_HEAD_AUX(x, ...) x + +#define ML99_PRIV_TAIL(...) ML99_PRIV_TAIL_AUX(__VA_ARGS__) +#define ML99_PRIV_TAIL_AUX(_x, ...) __VA_ARGS__ + +#define ML99_PRIV_SND(...) ML99_PRIV_SND_AUX(__VA_ARGS__, ~) +#define ML99_PRIV_SND_AUX(_x, y, ...) y + +#define ML99_PRIV_CONTAINS_COMMA(...) ML99_PRIV_X_AS_COMMA(__VA_ARGS__, ML99_PRIV_COMMA(), ~) +#define ML99_PRIV_X_AS_COMMA(_head, x, ...) ML99_PRIV_CONTAINS_COMMA_RESULT(x, 0, 1, ~) +#define ML99_PRIV_CONTAINS_COMMA_RESULT(x, _, result, ...) result + +#endif // ML99_PRIV_UTIL_H diff --git a/test/external/metalang99/include/metalang99/seq.h b/test/external/metalang99/include/metalang99/seq.h new file mode 100644 index 0000000..be2efae --- /dev/null +++ b/test/external/metalang99/include/metalang99/seq.h @@ -0,0 +1,204 @@ +/** + * @file + * Sequences: `(x)(y)(z)`. + * + * A sequence is represented as `(...) (...) ...`. For example, these are sequences: + * - `(~, ~, ~)` + * - `(1)(2)(3)` + * - `(+, -, *, /)(123)(~)` + * + * Sequences can represent syntax like `X(...) Y(...) Z(...)`, where `X`, `Y`, and `Z` expand to a + * [tuple](tuple.html), thereby forming a sequence. A perfect example is + * [Interface99](https://github.com/hirrolot/interface99), which allows a user to define a software + * interface via a number of `vfunc(...)` macro invocations: + * + * @code + * #define Shape_IFACE \ + * vfunc( int, perim, const VSelf) \ + * vfunc(void, scale, VSelf, int factor) + * + * interface(Shape); + * @endcode + * + * With `vfunc` being defined as follows (simplified): + * + * @code + * #define vfunc(ret_ty, name, ...) (ret_ty, name, __VA_ARGS__) + * @endcode + * + * @note Sequences are more time and space-efficient than lists, but export less functionality; if a + * needed function is missed, invoking #ML99_listFromSeq and then manipulating with the resulting + * Cons-list might be helpful. + */ + +#ifndef ML99_SEQ_H +#define ML99_SEQ_H + +#include <metalang99/nat/inc.h> +#include <metalang99/priv/tuple.h> +#include <metalang99/priv/util.h> + +#include <metalang99/lang.h> + +/** + * True iff @p seq contains no elements (which means an empty preprocessing lexeme). + * + * # Examples + * + * @code + * #include <metalang99/seq.h> + * + * // 1 + * ML99_seqIsEmpty(v()) + * + * // 0 + * ML99_seqIsEmpty(v((~)(~)(~))) + * @endcode + */ +#define ML99_seqIsEmpty(seq) ML99_call(ML99_seqIsEmpty, seq) + +/** + * Expands to a metafunction extracting the @p i -indexed element of @p seq. + * + * @p i can range from 0 to 7, inclusively. + * + * # Examples + * + * @code + * #include <metalang99/seq.h> + * + * // 2 + * ML99_seqGet(1)(v((1)(2)(3))) + * @endcode + */ +#define ML99_seqGet(i) ML99_PRIV_CAT(ML99_PRIV_seqGet_, i) + +/** + * Extracts the tail of @p seq. + * + * @p seq must contain at least one element. If @p seq contains **only** one element, the result is + * `ML99_empty()`. + * + * # Examples + * + * @code + * #include <metalang99/seq.h> + * + * // (2)(3) + * ML99_seqTail(v((1)(2)(3))) + * @endcode + */ +#define ML99_seqTail(seq) ML99_call(ML99_seqTail, seq) + +/** + * Applies @p f to each element in @p seq. + * + * The result is `ML99_appl(f, x1) ... ML99_appl(f, xN)`. + * + * # Examples + * + * @code + * #include <metalang99/seq.h> + * + * #define F_IMPL(x) v(@x) + * #define F_ARITY 1 + * + * // @x @y @z + * ML99_seqForEach(v(F), v((x)(y)(z))) + * @endcode + */ +#define ML99_seqForEach(f, seq) ML99_call(ML99_seqForEach, f, seq) + +/** + * Applies @p f to each element in @p seq with an index. + * + * The result is `ML99_appl2(f, 0, x1) ... ML99_appl2(f, N - 1, xN)`. + * + * @code + * #include <metalang99/seq.h> + * + * #define F_IMPL(i, x) v(@x##i) + * #define F_ARITY 2 + * + * // @x0 @y1 @z2 + * ML99_seqForEachI(v(F), v((x)(y)(z))) + * @endcode + */ +#define ML99_seqForEachI(f, seq) ML99_call(ML99_seqForEachI, f, seq) + +#define ML99_SEQ_IS_EMPTY(seq) ML99_PRIV_NOT(ML99_PRIV_CONTAINS_COMMA(ML99_PRIV_COMMA seq)) +#define ML99_SEQ_GET(i) ML99_PRIV_CAT(ML99_PRIV_SEQ_GET_, i) +#define ML99_SEQ_TAIL(seq) ML99_PRIV_TAIL(ML99_PRIV_COMMA seq) + +#ifndef DOXYGEN_IGNORE + +#define ML99_seqIsEmpty_IMPL(seq) v(ML99_SEQ_IS_EMPTY(seq)) + +#define ML99_PRIV_seqGet_0(seq) ML99_call(ML99_PRIV_seqGet_0, seq) +#define ML99_PRIV_seqGet_1(seq) ML99_call(ML99_PRIV_seqGet_1, seq) +#define ML99_PRIV_seqGet_2(seq) ML99_call(ML99_PRIV_seqGet_2, seq) +#define ML99_PRIV_seqGet_3(seq) ML99_call(ML99_PRIV_seqGet_3, seq) +#define ML99_PRIV_seqGet_4(seq) ML99_call(ML99_PRIV_seqGet_4, seq) +#define ML99_PRIV_seqGet_5(seq) ML99_call(ML99_PRIV_seqGet_5, seq) +#define ML99_PRIV_seqGet_6(seq) ML99_call(ML99_PRIV_seqGet_6, seq) +#define ML99_PRIV_seqGet_7(seq) ML99_call(ML99_PRIV_seqGet_7, seq) + +#define ML99_PRIV_seqGet_0_IMPL(seq) v(ML99_SEQ_GET(0)(seq)) +#define ML99_PRIV_seqGet_1_IMPL(seq) v(ML99_SEQ_GET(1)(seq)) +#define ML99_PRIV_seqGet_2_IMPL(seq) v(ML99_SEQ_GET(2)(seq)) +#define ML99_PRIV_seqGet_3_IMPL(seq) v(ML99_SEQ_GET(3)(seq)) +#define ML99_PRIV_seqGet_4_IMPL(seq) v(ML99_SEQ_GET(4)(seq)) +#define ML99_PRIV_seqGet_5_IMPL(seq) v(ML99_SEQ_GET(5)(seq)) +#define ML99_PRIV_seqGet_6_IMPL(seq) v(ML99_SEQ_GET(6)(seq)) +#define ML99_PRIV_seqGet_7_IMPL(seq) v(ML99_SEQ_GET(7)(seq)) + +#define ML99_PRIV_SEQ_GET_0(seq) ML99_PRIV_UNTUPLE(ML99_PRIV_HEAD(ML99_PRIV_SEQ_SEPARATE seq)) +#define ML99_PRIV_SEQ_GET_1(seq) ML99_PRIV_SEQ_GET_0(ML99_SEQ_TAIL(seq)) +#define ML99_PRIV_SEQ_GET_2(seq) ML99_PRIV_SEQ_GET_1(ML99_SEQ_TAIL(seq)) +#define ML99_PRIV_SEQ_GET_3(seq) ML99_PRIV_SEQ_GET_2(ML99_SEQ_TAIL(seq)) +#define ML99_PRIV_SEQ_GET_4(seq) ML99_PRIV_SEQ_GET_3(ML99_SEQ_TAIL(seq)) +#define ML99_PRIV_SEQ_GET_5(seq) ML99_PRIV_SEQ_GET_4(ML99_SEQ_TAIL(seq)) +#define ML99_PRIV_SEQ_GET_6(seq) ML99_PRIV_SEQ_GET_5(ML99_SEQ_TAIL(seq)) +#define ML99_PRIV_SEQ_GET_7(seq) ML99_PRIV_SEQ_GET_6(ML99_SEQ_TAIL(seq)) + +#define ML99_PRIV_SEQ_SEPARATE(...) (__VA_ARGS__), + +#define ML99_seqTail_IMPL(seq) v(ML99_SEQ_TAIL(seq)) + +#define ML99_seqForEach_IMPL(f, seq) \ + ML99_PRIV_CAT(ML99_PRIV_seqForEach_, ML99_SEQ_IS_EMPTY(seq))(f, seq) +#define ML99_PRIV_seqForEach_1(...) v(ML99_PRIV_EMPTY()) +#define ML99_PRIV_seqForEach_0(f, seq) \ + ML99_TERMS( \ + ML99_appl_IMPL(f, ML99_SEQ_GET(0)(seq)), \ + ML99_callUneval(ML99_seqForEach, f, ML99_SEQ_TAIL(seq))) + +#define ML99_seqForEachI_IMPL(f, seq) ML99_PRIV_seqForEachIAux_IMPL(f, 0, seq) +#define ML99_PRIV_seqForEachIAux_IMPL(f, i, seq) \ + ML99_PRIV_CAT(ML99_PRIV_seqForEachI_, ML99_SEQ_IS_EMPTY(seq))(f, i, seq) +#define ML99_PRIV_seqForEachI_1(...) v(ML99_PRIV_EMPTY()) +#define ML99_PRIV_seqForEachI_0(f, i, seq) \ + ML99_TERMS( \ + ML99_appl2_IMPL(f, i, ML99_SEQ_GET(0)(seq)), \ + ML99_callUneval(ML99_PRIV_seqForEachIAux, f, ML99_PRIV_INC(i), ML99_SEQ_TAIL(seq))) + +// Arity specifiers { + +#define ML99_seqIsEmpty_ARITY 1 +#define ML99_seqTail_ARITY 1 +#define ML99_seqForEach_ARITY 2 +#define ML99_seqForEachI_ARITY 2 + +#define ML99_PRIV_seqGet_0_ARITY 1 +#define ML99_PRIV_seqGet_1_ARITY 1 +#define ML99_PRIV_seqGet_2_ARITY 1 +#define ML99_PRIV_seqGet_3_ARITY 1 +#define ML99_PRIV_seqGet_4_ARITY 1 +#define ML99_PRIV_seqGet_5_ARITY 1 +#define ML99_PRIV_seqGet_6_ARITY 1 +#define ML99_PRIV_seqGet_7_ARITY 1 +// } (Arity specifiers) + +#endif // DOXYGEN_IGNORE + +#endif // ML99_SEQ_H diff --git a/test/external/metalang99/include/metalang99/stmt.h b/test/external/metalang99/include/metalang99/stmt.h new file mode 100644 index 0000000..54bb28f --- /dev/null +++ b/test/external/metalang99/include/metalang99/stmt.h @@ -0,0 +1,167 @@ +/** + * @file + * Statement chaining. + * + * This module exports a bunch of so-called _statement chaining macros_: they expect a statement + * right after their invocation, and moreover, an invocation of such a macro with a statement + * afterwards altogether form a single statement. + * + * How can this be helpful? Imagine you are writing a macro with the following syntax: + * + * @code + * MY_MACRO(...) { bla bla bla } + * @endcode + * + * Then `MY_MACRO` must expand to a _statement prefix_, i.e., something that expects a statement + * after itself. One possible solution is to make `MY_MACRO` expand to a sequence of statement + * chaining macros like this: + * + * @code + * #define MY_MACRO(...) \ + * ML99_INTRODUCE_VAR_TO_STMT(int x = 5) \ + * ML99_CHAIN_EXPR_STMT(printf("%d\n", x)) \ + * // and so on... + * @endcode + * + * Here #ML99_INTRODUCE_VAR_TO_STMT accepts the statement formed by #ML99_CHAIN_EXPR_STMT, which, in + * turn, accepts the next statement and so on, until a caller of `MY_MACRO` specifies the final + * statement, thus completing the chain. + * + * @see https://www.chiark.greenend.org.uk/~sgtatham/mp/ for a more involved explanation. + */ + +#ifndef ML99_STMT_H +#define ML99_STMT_H + +#include <metalang99/util.h> + +/** + * A statement chaining macro that introduces several variable definitions to a statement right + * after its invocation. + * + * Variable definitions must be specified as in the first clause of the for-loop. + * + * Top-level `break`/`continue` inside a user-provided statement are prohibited. + * + * # Example + * + * @code + * #include <metalang99/stmt.h> + * + * for (int i = 0; i < 10; i++) + * ML99_INTRODUCE_VAR_TO_STMT(double x = 5.0, y = 7.0) + * if (i % 2 == 0) + * printf("i = %d, x = %f, y = %f\n", i, x, y); + * @endcode + */ +#define ML99_INTRODUCE_VAR_TO_STMT(...) ML99_PRIV_INTRODUCE_VAR_TO_STMT_INNER(__VA_ARGS__) + +/** + * The same as #ML99_INTRODUCE_VAR_TO_STMT but deals with a single non-`NULL` pointer. + * + * In comparison with #ML99_INTRODUCE_VAR_TO_STMT, this macro generates a little less code. It + * introduces a pointer to @p ty identified by @p name and initialized to @p init. + * + * Top-level `break`/`continue` inside a user-provided statement are prohibited. + * + * # Example + * + * @code + * #include <metalang99/stmt.h> + * + * double x = 5.0, y = 7.0; + * + * for (int i = 0; i < 10; i++) + * ML99_INTRODUCE_NON_NULL_PTR_TO_STMT(double, x_ptr, &x) + * ML99_INTRODUCE_NON_NULL_PTR_TO_STMT(double, y_ptr, &y) + * printf("i = %d, x = %f, y = %f\n", i, *x_ptr, *y_ptr); + * @endcode + * + * @note Unlike #ML99_INTRODUCE_VAR_TO_STMT, the generated pointer is guaranteed to be used at least + * once, meaning that you do not need to suppress the unused variable warning. + * @note @p init is guaranteed to be executed only once. + */ +#define ML99_INTRODUCE_NON_NULL_PTR_TO_STMT(ty, name, init) \ + ML99_PRIV_SHADOWS(for (ty *name = (init); name != 0; name = 0)) + +/** + * A statement chaining macro that executes an expression statement derived from @p expr right + * before the next statement. + * + * Top-level `break`/`continue` inside a user-provided statement are prohibited. + * + * # Example + * + * @code + * #include <metalang99/stmt.h> + * + * int x; + * + * for(;;) + * ML99_CHAIN_EXPR_STMT(x = 5) + * ML99_CHAIN_EXPR_STMT(printf("%d\n", x)) + * puts("abc"); + * @endcode + */ +#define ML99_CHAIN_EXPR_STMT(expr) \ + ML99_PRIV_SHADOWS(for (int ml99_priv_expr_stmt_break = ((expr), 0); \ + ml99_priv_expr_stmt_break != 1; \ + ml99_priv_expr_stmt_break = 1)) + +/** + * The same as #ML99_CHAIN_EXPR_STMT but executes @p expr **after** the next statement. + */ +#define ML99_CHAIN_EXPR_STMT_AFTER(expr) \ + ML99_PRIV_SHADOWS(for (int ml99_priv_expr_stmt_after_break = 0; \ + ml99_priv_expr_stmt_after_break != 1; \ + ((expr), ml99_priv_expr_stmt_after_break = 1))) + +/** + * A statement chaining macro that suppresses the "unused X" warning right before a statement after + * its invocation. + * + * Top-level `break`/`continue` inside a user-provided statement are prohibited. + * + * # Example + * + * @code + * #include <metalang99/stmt.h> + * + * int x, y; + * + * for(;;) + * ML99_SUPPRESS_UNUSED_BEFORE_STMT(x) + * ML99_SUPPRESS_UNUSED_BEFORE_STMT(y) + * puts("abc"); + * @endcode + * + * @deprecated Use `ML99_CHAIN_EXPR_STMT((void)expr)` instead. + */ +#define ML99_SUPPRESS_UNUSED_BEFORE_STMT(expr) ML99_CHAIN_EXPR_STMT((void)expr) + +#ifndef DOXYGEN_IGNORE + +// See <https://github.com/hirrolot/metalang99/issues/25>. +#ifdef __cplusplus +#define ML99_PRIV_INTRODUCE_VAR_TO_STMT_INNER(...) \ + ML99_PRIV_SHADOWS(for (__VA_ARGS__, \ + *ml99_priv_break_arr[] = {0, 0}, \ + **ml99_priv_break = &ml99_priv_break_arr[0]; \ + ml99_priv_break == &ml99_priv_break_arr[0]; \ + ml99_priv_break++)) +#else +#define ML99_PRIV_INTRODUCE_VAR_TO_STMT_INNER(...) \ + ML99_PRIV_SHADOWS(for (__VA_ARGS__, *ml99_priv_break = (void *)0; \ + ml99_priv_break != (void *)1; \ + ml99_priv_break = (void *)1)) +#endif + +#define ML99_PRIV_SHADOWS(...) \ + ML99_CLANG_PRAGMA("clang diagnostic push") \ + ML99_CLANG_PRAGMA("clang diagnostic ignored \"-Wshadow\"") \ + __VA_ARGS__ \ + ML99_CLANG_PRAGMA("clang diagnostic pop") + +#endif // DOXYGEN_IGNORE + +#endif // ML99_STMT_H diff --git a/test/external/metalang99/include/metalang99/tuple.h b/test/external/metalang99/include/metalang99/tuple.h new file mode 100644 index 0000000..da92298 --- /dev/null +++ b/test/external/metalang99/include/metalang99/tuple.h @@ -0,0 +1,371 @@ +/** + * @file + * Tuples: `(x, y, z)`. + * + * A tuple is represented as `(x1, ..., xN)`. Tuples are a convenient way to deal with product + * types. For example: + * + * [[examples/rectangle.c](https://github.com/hirrolot/metalang99/blob/master/examples/rectangle.c)] + * @include rectangle.c + * + * @note Tuples are more time and space-efficient than lists, but export less functionality; if a + * needed function is missed, invoking #ML99_list and then manipulating with the resulting Cons-list + * might be helpful. + */ + +#ifndef ML99_TUPLE_H +#define ML99_TUPLE_H + +#include <metalang99/priv/bool.h> +#include <metalang99/priv/tuple.h> +#include <metalang99/priv/util.h> + +#include <metalang99/lang.h> +#include <metalang99/variadics.h> + +/** + * Transforms a sequence of arguments into `(...)`. + * + * # Examples + * + * @code + * #include <metalang99/tuple.h> + * + * // (1, 2, 3) + * ML99_tuple(v(1, 2, 3)) + * @endcode + */ +#define ML99_tuple(...) ML99_call(ML99_tuple, __VA_ARGS__) + +/** + * Transforms a sequence of arguments into `(v(...))`. + * + * # Examples + * + * @code + * #include <metalang99/tuple.h> + * + * // (v(1, 2, 3)) + * ML99_tupleEval(v(1, 2, 3)) + * @endcode + * + * @deprecated I have seen no single use case over time. Please, [open an + * issue](https://github.com/hirrolot/metalang99/issues/new/choose) if you need this function. + */ +#define ML99_tupleEval(...) ML99_call(ML99_tupleEval, __VA_ARGS__) + +/** + * Untuples the tuple @p x, leaving the result unevaluated. + * + * If @p x is not a tuple, it emits a fatal error. + * + * # Examples + * + * @code + * #include <metalang99/tuple.h> + * + * // 1, 2, 3 + * ML99_untuple(v((1, 2, 3))) + * @endcode + */ +#define ML99_untuple(x) ML99_call(ML99_untuple, x) + +/** + * The same as #ML99_untuple. + * + * @deprecated Use #ML99_untuple instead. + */ +#define ML99_untupleChecked(x) ML99_call(ML99_untupleChecked, x) + +/** + * Untuples the tuple @p x and evaluates the result. + * + * # Examples + * + * @code + * #include <metalang99/tuple.h> + * + * // 1, 2, 3 + * ML99_untupleEval(v((v(1, 2, 3)))) + * @endcode + * + * @deprecated For the same reason as #ML99_tupleEval. + */ +#define ML99_untupleEval(x) ML99_call(ML99_untupleEval, x) + +/** + * Tests whether @p x is inside parentheses or not. + * + * The preconditions are the same as of #ML99_isUntuple. + * + * # Examples + * + * @code + * #include <metalang99/tuple.h> + * + * // 0 + * ML99_isTuple(v(123)) + * + * // 1 + * ML99_isTuple(v((123))) + * @endcode + */ +#define ML99_isTuple(x) ML99_call(ML99_isTuple, x) + +/** + * The inverse of #ML99_isTuple. + * + * @p x must be either of these forms: + * - `(...)` (reported as non-untupled) + * - `(...) (...) ...` (reported as untupled) + * - anything else not beginning with `(...)` (reported as untupled) + * + * For example (respectively): + * - `(~, ~, ~)` (non-untupled) + * - `(~, ~, ~) (~, ~, ~)` or `(~, ~, ~) (~, ~, ~) abc` (untupled) + * - `123` or `123 (~, ~, ~)` (untupled) + * + * # Examples + * + * @code + * #include <metalang99/tuple.h> + * + * // 1 + * ML99_isUntuple(v(123)) + * + * // 0 + * ML99_isUntuple(v((123))) + * + * // 1 + * ML99_isUntuple(v((123) (456) (789))) + * @endcode + */ +#define ML99_isUntuple(x) ML99_call(ML99_isUntuple, x) + +/** + * Computes the count of items in the tuple @p x. + * + * At most 63 items can be contained in @p x. + * + * # Examples + * + * @code + * #include <metalang99/tuple.h> + * + * // 3 + * ML99_tupleCount(v((~, ~, ~))) + * + * // 1 + * ML99_tupleCount(v(())) + * @endcode + */ +#define ML99_tupleCount(x) ML99_call(ML99_tupleCount, x) + +/** + * Tells if the tuple @p x contains only one item or not. + * + * # Examples + * + * @code + * #include <metalang99/tuple.h> + * + * // 1 + * ML99_tupleIsSingle(v((~))) + * + * // 0 + * ML99_tupleIsSingle(v((~, ~, ~))) + * @endcode + */ +#define ML99_tupleIsSingle(x) ML99_call(ML99_tupleIsSingle, x) + +/** + * Expands to a metafunction extracting the @p i -indexed element of a tuple. + * + * @p i can range from 0 to 7, inclusively. + * + * # Examples + * + * @code + * #include <metalang99/tuple.h> + * + * // 2 + * ML99_tupleGet(1)(v((1, 2, 3))) + * @endcode + */ +#define ML99_tupleGet(i) ML99_PRIV_CAT(ML99_PRIV_tupleGet_, i) + +/** + * Extracts the tuple's tail. + * + * @p x must contain at least two elements. + * + * # Examples + * + * @code + * #include <metalang99/tuple.h> + * + * // 2, 3 + * ML99_tupleTail(v((1, 2, 3))) + * @endcode + */ +#define ML99_tupleTail(x) ML99_call(ML99_tupleTail, x) + +/** + * Appends provided variadic arguments to the tuple @p x. + * + * # Examples + * + * @code + * #include <metalang99/tuple.h> + * + * // (1, 2, 3) + * ML99_tupleAppend(ML99_tuple(v(1)), v(2, 3)) + * @endcode + */ +#define ML99_tupleAppend(x, ...) ML99_call(ML99_tupleAppend, x, __VA_ARGS__) + +/** + * Prepends provided variadic arguments to the tuple @p x. + * + * # Examples + * + * @code + * #include <metalang99/tuple.h> + * + * // (1, 2, 3) + * ML99_tuplePrepend(ML99_tuple(v(3)), v(1, 2)) + * @endcode + */ +#define ML99_tuplePrepend(x, ...) ML99_call(ML99_tuplePrepend, x, __VA_ARGS__) + +/** + * A shortcut for `ML99_variadicsForEach(f, ML99_untuple(x))`. + */ +#define ML99_tupleForEach(f, x) ML99_call(ML99_tupleForEach, f, x) + +/** + * A shortcut for `ML99_variadicsForEachI(f, ML99_untuple(x))`. + */ +#define ML99_tupleForEachI(f, x) ML99_call(ML99_tupleForEachI, f, x) + +/** + * Emits a fatal error if @p x is not a tuple, otherwise results in emptiness. + * + * # Examples + * + * @code + * #include <metalang99/tuple.h> + * + * #define F_IMPL(x) ML99_TERMS(ML99_assertIsTuple(v(x)), ML99_untuple(v(x))) + * + * // 1, 2, 3 + * ML99_call(F, v((1, 2, 3))) + * + * // A compile-time tuple mismatch error. + * ML99_call(F, v(123)) + * @endcode + */ +#define ML99_assertIsTuple(x) ML99_call(ML99_assertIsTuple, x) + +#define ML99_TUPLE(...) (__VA_ARGS__) +#define ML99_UNTUPLE(x) ML99_PRIV_EXPAND x +#define ML99_IS_TUPLE(x) ML99_PRIV_IS_TUPLE(x) +#define ML99_IS_UNTUPLE(x) ML99_PRIV_IS_UNTUPLE(x) +#define ML99_TUPLE_COUNT(x) ML99_VARIADICS_COUNT(ML99_UNTUPLE(x)) +#define ML99_TUPLE_IS_SINGLE(x) ML99_VARIADICS_IS_SINGLE(ML99_UNTUPLE(x)) +#define ML99_TUPLE_GET(i) ML99_PRIV_CAT(ML99_PRIV_TUPLE_GET_, i) +#define ML99_TUPLE_TAIL(x) ML99_VARIADICS_TAIL(ML99_UNTUPLE(x)) +#define ML99_TUPLE_APPEND(x, ...) (ML99_UNTUPLE(x), __VA_ARGS__) +#define ML99_TUPLE_PREPEND(x, ...) (__VA_ARGS__, ML99_UNTUPLE(x)) + +#ifndef DOXYGEN_IGNORE + +#define ML99_tuple_IMPL(...) v(ML99_TUPLE(__VA_ARGS__)) +#define ML99_tupleEval_IMPL(...) v((v(__VA_ARGS__))) +#define ML99_untuple_IMPL(x) \ + ML99_PRIV_IF(ML99_IS_TUPLE(x), ML99_PRIV_UNTUPLE_TERM, ML99_PRIV_NOT_TUPLE_ERROR)(x) +#define ML99_untupleChecked_IMPL(x) ML99_untuple_IMPL(x) +#define ML99_untupleEval_IMPL(x) ML99_PRIV_EXPAND x +#define ML99_isTuple_IMPL(x) v(ML99_IS_TUPLE(x)) +#define ML99_isUntuple_IMPL(x) v(ML99_IS_UNTUPLE(x)) +#define ML99_tupleCount_IMPL(x) v(ML99_TUPLE_COUNT(x)) +#define ML99_tupleIsSingle_IMPL(x) v(ML99_TUPLE_IS_SINGLE(x)) + +#define ML99_PRIV_UNTUPLE_TERM(x) v(ML99_UNTUPLE(x)) + +#define ML99_PRIV_tupleGet_0(x) ML99_call(ML99_PRIV_tupleGet_0, x) +#define ML99_PRIV_tupleGet_1(x) ML99_call(ML99_PRIV_tupleGet_1, x) +#define ML99_PRIV_tupleGet_2(x) ML99_call(ML99_PRIV_tupleGet_2, x) +#define ML99_PRIV_tupleGet_3(x) ML99_call(ML99_PRIV_tupleGet_3, x) +#define ML99_PRIV_tupleGet_4(x) ML99_call(ML99_PRIV_tupleGet_4, x) +#define ML99_PRIV_tupleGet_5(x) ML99_call(ML99_PRIV_tupleGet_5, x) +#define ML99_PRIV_tupleGet_6(x) ML99_call(ML99_PRIV_tupleGet_6, x) +#define ML99_PRIV_tupleGet_7(x) ML99_call(ML99_PRIV_tupleGet_7, x) + +#define ML99_PRIV_tupleGet_0_IMPL(x) v(ML99_TUPLE_GET(0)(x)) +#define ML99_PRIV_tupleGet_1_IMPL(x) v(ML99_TUPLE_GET(1)(x)) +#define ML99_PRIV_tupleGet_2_IMPL(x) v(ML99_TUPLE_GET(2)(x)) +#define ML99_PRIV_tupleGet_3_IMPL(x) v(ML99_TUPLE_GET(3)(x)) +#define ML99_PRIV_tupleGet_4_IMPL(x) v(ML99_TUPLE_GET(4)(x)) +#define ML99_PRIV_tupleGet_5_IMPL(x) v(ML99_TUPLE_GET(5)(x)) +#define ML99_PRIV_tupleGet_6_IMPL(x) v(ML99_TUPLE_GET(6)(x)) +#define ML99_PRIV_tupleGet_7_IMPL(x) v(ML99_TUPLE_GET(7)(x)) + +#define ML99_PRIV_TUPLE_GET_0(x) ML99_VARIADICS_GET(0)(ML99_UNTUPLE(x)) +#define ML99_PRIV_TUPLE_GET_1(x) ML99_VARIADICS_GET(1)(ML99_UNTUPLE(x)) +#define ML99_PRIV_TUPLE_GET_2(x) ML99_VARIADICS_GET(2)(ML99_UNTUPLE(x)) +#define ML99_PRIV_TUPLE_GET_3(x) ML99_VARIADICS_GET(3)(ML99_UNTUPLE(x)) +#define ML99_PRIV_TUPLE_GET_4(x) ML99_VARIADICS_GET(4)(ML99_UNTUPLE(x)) +#define ML99_PRIV_TUPLE_GET_5(x) ML99_VARIADICS_GET(5)(ML99_UNTUPLE(x)) +#define ML99_PRIV_TUPLE_GET_6(x) ML99_VARIADICS_GET(6)(ML99_UNTUPLE(x)) +#define ML99_PRIV_TUPLE_GET_7(x) ML99_VARIADICS_GET(7)(ML99_UNTUPLE(x)) + +#define ML99_tupleTail_IMPL(x) v(ML99_TUPLE_TAIL(x)) + +#define ML99_tupleAppend_IMPL(x, ...) v(ML99_TUPLE_APPEND(x, __VA_ARGS__)) +#define ML99_tuplePrepend_IMPL(x, ...) v(ML99_TUPLE_PREPEND(x, __VA_ARGS__)) +#define ML99_tupleForEach_IMPL(f, x) ML99_variadicsForEach_IMPL(f, ML99_UNTUPLE(x)) +#define ML99_tupleForEachI_IMPL(f, x) ML99_variadicsForEachI_IMPL(f, ML99_UNTUPLE(x)) + +#define ML99_assertIsTuple_IMPL(x) \ + ML99_PRIV_IF(ML99_IS_UNTUPLE(x), ML99_PRIV_NOT_TUPLE_ERROR(x), v(ML99_PRIV_EMPTY())) + +// clang-format off +#define ML99_PRIV_NOT_TUPLE_ERROR(x) \ + ML99_PRIV_IF( \ + ML99_PRIV_IS_DOUBLE_TUPLE_BEGINNING(x), \ + ML99_fatal(ML99_assertIsTuple, x must be (x1, ..., xN), did you miss a comma?), \ + ML99_fatal(ML99_assertIsTuple, x must be (x1, ..., xN))) +// clang-format on + +// Arity specifiers { + +#define ML99_tuple_ARITY 1 +#define ML99_tupleEval_ARITY 1 +#define ML99_untuple_ARITY 1 +#define ML99_untupleChecked_ARITY 1 +#define ML99_untupleEval_ARITY 1 +#define ML99_isTuple_ARITY 1 +#define ML99_isUntuple_ARITY 1 +#define ML99_tupleCount_ARITY 1 +#define ML99_tupleIsSingle_ARITY 1 +#define ML99_tupleTail_ARITY 1 +#define ML99_tupleAppend_ARITY 2 +#define ML99_tuplePrepend_ARITY 2 +#define ML99_tupleForEach_ARITY 2 +#define ML99_tupleForEachI_ARITY 2 +#define ML99_assertIsTuple_ARITY 1 + +#define ML99_PRIV_tupleGet_0_ARITY 1 +#define ML99_PRIV_tupleGet_1_ARITY 1 +#define ML99_PRIV_tupleGet_2_ARITY 1 +#define ML99_PRIV_tupleGet_3_ARITY 1 +#define ML99_PRIV_tupleGet_4_ARITY 1 +#define ML99_PRIV_tupleGet_5_ARITY 1 +#define ML99_PRIV_tupleGet_6_ARITY 1 +#define ML99_PRIV_tupleGet_7_ARITY 1 +// } (Arity specifiers) + +#endif // DOXYGEN_IGNORE + +#endif // ML99_TUPLE_H diff --git a/test/external/metalang99/include/metalang99/util.h b/test/external/metalang99/include/metalang99/util.h new file mode 100644 index 0000000..b4be573 --- /dev/null +++ b/test/external/metalang99/include/metalang99/util.h @@ -0,0 +1,444 @@ +/** + * @file + * Utilitary stuff. + */ + +#ifndef ML99_UTIL_H +#define ML99_UTIL_H + +#include <metalang99/priv/util.h> + +#include <metalang99/ident.h> // For backwards compatibility. +#include <metalang99/lang.h> + +/** + * Concatenates @p a with @p b and evaluates the result. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * #define ABC123 v(Billie Jean) + * + * // Billie Jean + * ML99_catEval(v(ABC), v(123)) + * + * // ERROR: 123ABC is not a valid Metalang99 term. + * ML99_catEval(v(123), v(ABC)) + * @endcode + * + * @deprecated I have seen no single use case over time. Please, [open an + * issue](https://github.com/hirrolot/metalang99/issues/new/choose) if you need this function. + */ +#define ML99_catEval(a, b) ML99_call(ML99_catEval, a, b) + +/** + * Concatenates @p a with @p b, leaving the result unevaluated. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * #define ABC123 Billie Jean + * + * // Billie Jean + * ML99_cat(v(ABC), v(123)) + * + * // 123ABC + * ML99_cat(v(123), v(ABC)) + * @endcode + */ +#define ML99_cat(a, b) ML99_call(ML99_cat, a, b) + +/** + * The same as #ML99_cat but deals with 3 parameters. + */ +#define ML99_cat3(a, b, c) ML99_call(ML99_cat3, a, b, c) + +/** + * The same as #ML99_cat but deals with 4 parameters. + */ +#define ML99_cat4(a, b, c, d) ML99_call(ML99_cat4, a, b, c, d) + +/** + * Stringifies provided arguments. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * // "Billie Jean" + * ML99_stringify(v(Billie Jean)) + * @endcode + */ +#define ML99_stringify(...) ML99_call(ML99_stringify, __VA_ARGS__) + +/** + * Evaluates to nothing. + */ +#define ML99_empty(...) ML99_callUneval(ML99_empty, ) + +/** + * Evaluates to its arguments. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * // 1, 2, 3 + * ML99_id(v(1, 2, 3)) + * @endcode + */ +#define ML99_id(...) ML99_call(ML99_id, __VA_ARGS__) + +/** + * Evaluates to @p x, skipping @p a. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * // 123 + * ML99_const(v(123), v(5)) + * @endcode + */ +#define ML99_const(x, a) ML99_call(ML99_const, x, a) + +/** + * Reverses the order of arguments of the binary function @p f. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * // ABC123 + * ML99_appl2(ML99_flip(v(ML99_catUnevaluated)), v(123), v(ABC)) + * @endcode + */ +#define ML99_flip(f) ML99_call(ML99_flip, f) + +/** + * Accepts terms and evaluates them with the space-separator. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * // 1 2 3 + * ML99_uncomma(ML99_QUOTE(v(1), v(2), v(3))) + * @endcode + */ +#define ML99_uncomma(...) ML99_call(ML99_uncomma, __VA_ARGS__) + +/** + * Turns @p f into a Metalang99-compliant metafunction with the arity of 1, which can be then called + * by #ML99_appl. + * + * @p f can be any C function or function-like macro. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * #include <metalang99/variadics.h> + * + * #define F(x) @x + * + * // @1 @2 @3 + * ML99_variadicsForEach(ML99_reify(v(F)), v(1, 2, 3)) + * @endcode + * + * Without #ML99_reify, you would need to write some additional boilerplate: + * + * @code + * #define F_IMPL(x) v(@x) + * #define F_ARITY 1 + * @endcode + */ +#define ML99_reify(f) ML99_call(ML99_reify, f) + +/** + * Indicates not yet implemented functionality of the macro @p f. + * + * #ML99_todo is the same as #ML99_unimplemented except that the former conveys an intent that the + * functionality is to be implemented later but #ML99_unimplemented makes no such claims. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * // A not-yet implemented error. + * ML99_todo(v(F)) + * @endcode + * + * @see [Rust's std::todo\!](https://doc.rust-lang.org/core/macro.todo.html) (thanks for the idea!) + */ +#define ML99_todo(f) ML99_call(ML99_todo, f) + +/** + * The same as #ML99_todo but emits a caller-supplied message. + * + * @p message must be a string literal. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * // A not-yet-implemented error. + * ML99_todoWithMsg(v(F), v("your message")) + * @endcode + */ +#define ML99_todoWithMsg(f, message) ML99_call(ML99_todoWithMsg, f, message) + +/** + * Indicates unimplemented functionality of the macro @p f. + * + * #ML99_unimplemented is the same as #ML99_todo except that the latter conveys an intent that the + * functionality is to be implemented later but #ML99_unimplemented makes no such claims. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * // A not-implemented error. + * ML99_unimplemented(v(F)) + * @endcode + * + * @see [Rust's std::unimplemented\!](https://doc.rust-lang.org/core/macro.unimplemented.html) + * (thanks for the idea!) + */ +#define ML99_unimplemented(f) ML99_call(ML99_unimplemented, f) + +/** + * The same as #ML99_unimplemented but emits a caller-supplied message. + * + * @p message must be a string literal. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * // A not-implemented error. + * ML99_unimplementedWithMsg(v(F), v("your message")) + * @endcode + */ +#define ML99_unimplementedWithMsg(f, message) ML99_call(ML99_unimplementedWithMsg, f, message) + +#ifdef __COUNTER__ + +/** + * Generates a unique identifier @p id in the namespace @p prefix. + * + * Let `FOO` be the name of an enclosing macro. Then `FOO_` must be specified for @p prefix, and @p + * id should be given any meaningful name (this makes debugging easier). + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * #define FOO(...) FOO_NAMED(ML99_GEN_SYM(FOO_, x), __VA_ARGS__) + * #define FOO_NAMED(x_sym, ...) \ + * do { int x_sym = 5; __VA_ARGS__ } while (0) + * + * // `x` here will not conflict with the `x` inside `FOO`. + * FOO({ + * int x = 7; + * printf("x is %d\n", x); // x is 7 + * }); + * @endcode + * + * @note Two identical calls to #ML99_GEN_SYM will yield different identifiers, therefore, to refer + * to the result later, you must save it in an auxiliary macro's parameter, as shown in the example + * above. + * @note #ML99_GEN_SYM is defined only if `__COUNTER__` is defined, which must be a macro yielding + * integral literals starting from 0 incremented by 1 each time it is called. Currently, it is + * supported at least by Clang, GCC, TCC, and MSVC. + * @see https://en.wikipedia.org/wiki/Hygienic_macro + */ +#define ML99_GEN_SYM(prefix, id) ML99_CAT4(prefix, id, _, __COUNTER__) + +#endif // __COUNTER__ + +/** + * Forces a caller to put a trailing semicolon. + * + * It is useful when defining macros, to make them formatted as complete statements. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * #define MY_MACRO(fn_name, val_ty, val) \ + * inline static val_ty fn_name(void) { return val; } \ + * ML99_TRAILING_SEMICOLON() + * + * // Defines a function that always returns 0. + * MY_MACRO(zero, int, 0); + * @endcode + * + * @note #ML99_TRAILING_SEMICOLON is to be used outside of functions: unlike the `do { ... } while + * (0)` idiom, this macro expands to a C declaration. + */ +#define ML99_TRAILING_SEMICOLON(...) struct ml99_priv_trailing_semicolon + +/** + * Concatenates @p a with @p b as-is, without expanding them. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * // This macro will not be expanded. + * #define ABC 7 + * + * // ABC123 + * ML99_CAT_PRIMITIVE(ABC, 123) + * @endcode + */ +#define ML99_CAT_PRIMITIVE(a, b) a##b + +/** + * The same as #ML99_CAT_PRIMITIVE but deals with 3 parameters. + */ +#define ML99_CAT3_PRIMITIVE(a, b, c) a##b##c + +/** + * The same as #ML99_CAT_PRIMITIVE but deals with 4 parameters. + */ +#define ML99_CAT4_PRIMITIVE(a, b, c, d) a##b##c##d + +/** + * Stringifies @p x as-is, without expanding it. + * + * # Examples + * + * @code + * #include <metalang99/util.h> + * + * // This macro will not be expanded. + * #define ABC 7 + * + * // "ABC" + * ML99_STRINGIFY_PRIMITIVE(ABC) + * @endcode + */ +#define ML99_STRINGIFY_PRIMITIVE(...) #__VA_ARGS__ + +/** + * Expands to an opening parenthesis (`(`). + * + * This is helpful when you want to delay macro arguments passing: just type `BAR ML99_LPAREN() + * initial args...` at the end of some macro `FOO` and complete the invocation of `BAR` with + * `the rest of args...)` in future. + * + * This macro consumes all its arguments. + * + * @deprecated This macro results in code that is difficult to reason about. + */ +#define ML99_LPAREN(...) ( + +/** + * The same as #ML99_LPAREN but emits a closing parenthesis. + * + * @deprecated For the same reason as #ML99_LPAREN. + */ +#define ML99_RPAREN(...) ) + +/** + * Expands to a single comma, consuming all arguments. + */ +#define ML99_COMMA(...) , + +/** + * If you are compiling on GCC, this macro expands to `_Pragma(str)`, otherwise to emptiness. + */ +#define ML99_GCC_PRAGMA(str) ML99_PRIV_GCC_PRAGMA(str) + +/** + * The same as #ML99_GCC_PRAGMA but for Clang. + */ +#define ML99_CLANG_PRAGMA(str) ML99_PRIV_CLANG_PRAGMA(str) + +#define ML99_CAT(a, b) ML99_CAT_PRIMITIVE(a, b) +#define ML99_CAT3(a, b, c) ML99_CAT3_PRIMITIVE(a, b, c) +#define ML99_CAT4(a, b, c, d) ML99_CAT4_PRIMITIVE(a, b, c, d) +#define ML99_STRINGIFY(...) ML99_STRINGIFY_PRIMITIVE(__VA_ARGS__) +#define ML99_EMPTY(...) +#define ML99_ID(...) __VA_ARGS__ + +#ifndef DOXYGEN_IGNORE + +#define ML99_catEval_IMPL(a, b) a##b +#define ML99_cat_IMPL(a, b) v(a##b) +#define ML99_cat3_IMPL(a, b, c) v(a##b##c) +#define ML99_cat4_IMPL(a, b, c, d) v(a##b##c##d) +#define ML99_stringify_IMPL(...) v(ML99_STRINGIFY(__VA_ARGS__)) +#define ML99_empty_IMPL(...) v(ML99_EMPTY()) +#define ML99_id_IMPL(...) v(ML99_ID(__VA_ARGS__)) +#define ML99_const_IMPL(x, _a) v(x) +#define ML99_flip_IMPL(f) ML99_appl_IMPL(ML99_PRIV_flip, f) +#define ML99_PRIV_flip_IMPL(f, a, b) ML99_appl2_IMPL(f, b, a) +#define ML99_uncomma_IMPL(...) __VA_ARGS__ + +#define ML99_reify_IMPL(f) ML99_appl_IMPL(ML99_PRIV_reify, f) +#define ML99_PRIV_reify_IMPL(f, ...) v(f(__VA_ARGS__)) + +// clang-format off +#define ML99_todo_IMPL(f) ML99_fatal(f, not yet implemented) +#define ML99_todoWithMsg_IMPL(f, message) ML99_fatal(f, not yet implemented: message) + +#define ML99_unimplemented_IMPL(f) ML99_fatal(f, not implemented) +#define ML99_unimplementedWithMsg_IMPL(f, message) ML99_fatal(f, not implemented: message) +// clang-format on + +#if defined(__GNUC__) && !defined(__clang__) +#define ML99_PRIV_GCC_PRAGMA(str) _Pragma(str) +#else +#define ML99_PRIV_GCC_PRAGMA(str) +#endif + +#if defined(__clang__) +#define ML99_PRIV_CLANG_PRAGMA(str) _Pragma(str) +#else +#define ML99_PRIV_CLANG_PRAGMA(str) +#endif + +// Arity specifiers { + +#define ML99_catEval_ARITY 2 +#define ML99_cat_ARITY 2 +#define ML99_cat3_ARITY 3 +#define ML99_cat4_ARITY 4 +#define ML99_stringify_ARITY 1 +#define ML99_empty_ARITY 1 +#define ML99_id_ARITY 1 +#define ML99_const_ARITY 2 +#define ML99_flip_ARITY 1 +#define ML99_uncomma_ARITY 1 +#define ML99_reify_ARITY 1 +#define ML99_todo_ARITY 1 +#define ML99_todoWithMsg_ARITY 2 +#define ML99_unimplemented_ARITY 1 +#define ML99_unimplementedWithMsg_ARITY 2 + +#define ML99_PRIV_flip_ARITY 3 +#define ML99_PRIV_reify_ARITY 2 +// } (Arity specifiers) + +#endif // DOXYGEN_IGNORE + +#endif // ML99_UTIL_H diff --git a/test/external/metalang99/include/metalang99/variadics.h b/test/external/metalang99/include/metalang99/variadics.h new file mode 100644 index 0000000..59b52c4 --- /dev/null +++ b/test/external/metalang99/include/metalang99/variadics.h @@ -0,0 +1,274 @@ +/** + * @file + * Variadic arguments: `x, y, z`. + * + * @note Variadics are more time and space-efficient than lists, but export less functionality; if a + * needed function is missed, invoking #ML99_list and then manipulating with the resulting Cons-list + * might be helpful. + */ + +#ifndef ML99_VARIADICS_H +#define ML99_VARIADICS_H + +#include <metalang99/nat/inc.h> +#include <metalang99/priv/util.h> + +#include <metalang99/lang.h> + +/** + * Computes a count of its arguments. + * + * At most 63 arguments are acceptable. + * + * # Examples + * + * @code + * #include <metalang99/variadics.h> + * + * // 3 + * ML99_variadicsCount(v(~, ~, ~)) + * + * // 1 + * ML99_variadicsCount() + * @endcode + */ +#define ML99_variadicsCount(...) ML99_call(ML99_variadicsCount, __VA_ARGS__) + +/** + * Tells if it received only one argument or not. + * + * # Examples + * + * @code + * #include <metalang99/variadics.h> + * + * // 1 + * ML99_variadicsIsSingle(v(~)) + * + * // 0 + * ML99_variadicsIsSingle(v(~, ~, ~)) + * @endcode + */ +#define ML99_variadicsIsSingle(...) ML99_call(ML99_variadicsIsSingle, __VA_ARGS__) + +/** + * Expands to a metafunction extracting the @p i -indexed argument. + * + * @p i can range from 0 to 7, inclusively. + * + * # Examples + * + * @code + * #include <metalang99/variadics.h> + * + * // 2 + * ML99_variadicsGet(1)(v(1, 2, 3)) + * @endcode + */ +#define ML99_variadicsGet(i) ML99_PRIV_CAT(ML99_PRIV_variadicsGet_, i) + +/** + * Extracts the tail of its arguments. + * + * At least two arguments must be specified. + * + * # Examples + * + * @code + * #include <metalang99/variadics.h> + * + * // 2, 3 + * ML99_variadicsTail(v(1, 2, 3)) + * @endcode + */ +#define ML99_variadicsTail(...) ML99_call(ML99_variadicsTail, __VA_ARGS__) + +/** + * Applies @p f to each argument. + * + * The result is `ML99_appl(f, x1) ... ML99_appl(f, xN)`. + * + * # Examples + * + * @code + * #include <metalang99/variadics.h> + * + * #define F_IMPL(x) v(@x) + * #define F_ARITY 1 + * + * // @x @y @z + * ML99_variadicsForEach(v(F), v(x, y, z)) + * @endcode + */ +#define ML99_variadicsForEach(f, ...) ML99_call(ML99_variadicsForEach, f, __VA_ARGS__) + +/** + * Applies @p f to each argument with an index. + * + * The result is `ML99_appl2(f, x1, 0) ... ML99_appl2(f, xN, N - 1)`. + * + * @code + * #include <metalang99/variadics.h> + * + * #define F_IMPL(x, i) v(@x##i) + * #define F_ARITY 2 + * + * // @x0 @y1 @z2 + * ML99_variadicsForEachI(v(F), v(x, y, z)) + * @endcode + */ +#define ML99_variadicsForEachI(f, ...) ML99_call(ML99_variadicsForEachI, f, __VA_ARGS__) + +/** + * Overloads @p f on a number of arguments. + * + * This function counts the number of provided arguments, appends it to @p f and calls the resulting + * macro identifier with provided arguments. + * + * At most 63 variadic arguments are acceptable. + * + * # Examples + * + * @code + * #include <metalang99/variadics.h> + * + * #define X(...) ML99_OVERLOAD(X_, __VA_ARGS__) + * #define X_1(a) Billie & a + * #define X_2(a, b) Jean & a & b + * + * // Billie & 4 + * X(4) + * + * // Jean & 5 & 6 + * X(5, 6) + * @endcode + * + * @note @p f need not be postfixed with `_IMPL`. It is literally invoked as `ML99_CAT(f, + * ML99_VARIADICS_COUNT(...))(...)`. + */ +#define ML99_OVERLOAD(f, ...) ML99_PRIV_CAT(f, ML99_PRIV_VARIADICS_COUNT(__VA_ARGS__))(__VA_ARGS__) + +#define ML99_VARIADICS_COUNT(...) ML99_PRIV_VARIADICS_COUNT(__VA_ARGS__) +#define ML99_VARIADICS_IS_SINGLE(...) ML99_PRIV_NOT(ML99_PRIV_CONTAINS_COMMA(__VA_ARGS__)) +#define ML99_VARIADICS_GET(i) ML99_PRIV_CAT(ML99_PRIV_VARIADICS_GET_, i) +#define ML99_VARIADICS_TAIL(...) ML99_PRIV_TAIL(__VA_ARGS__) + +#ifndef DOXYGEN_IGNORE + +#define ML99_variadicsCount_IMPL(...) v(ML99_VARIADICS_COUNT(__VA_ARGS__)) +#define ML99_variadicsIsSingle_IMPL(...) v(ML99_VARIADICS_IS_SINGLE(__VA_ARGS__)) + +#define ML99_PRIV_variadicsGet_0(...) ML99_call(ML99_PRIV_variadicsGet_0, __VA_ARGS__) +#define ML99_PRIV_variadicsGet_1(...) ML99_call(ML99_PRIV_variadicsGet_1, __VA_ARGS__) +#define ML99_PRIV_variadicsGet_2(...) ML99_call(ML99_PRIV_variadicsGet_2, __VA_ARGS__) +#define ML99_PRIV_variadicsGet_3(...) ML99_call(ML99_PRIV_variadicsGet_3, __VA_ARGS__) +#define ML99_PRIV_variadicsGet_4(...) ML99_call(ML99_PRIV_variadicsGet_4, __VA_ARGS__) +#define ML99_PRIV_variadicsGet_5(...) ML99_call(ML99_PRIV_variadicsGet_5, __VA_ARGS__) +#define ML99_PRIV_variadicsGet_6(...) ML99_call(ML99_PRIV_variadicsGet_6, __VA_ARGS__) +#define ML99_PRIV_variadicsGet_7(...) ML99_call(ML99_PRIV_variadicsGet_7, __VA_ARGS__) + +#define ML99_PRIV_variadicsGet_0_IMPL(...) v(ML99_VARIADICS_GET(0)(__VA_ARGS__)) +#define ML99_PRIV_variadicsGet_1_IMPL(...) v(ML99_VARIADICS_GET(1)(__VA_ARGS__)) +#define ML99_PRIV_variadicsGet_2_IMPL(...) v(ML99_VARIADICS_GET(2)(__VA_ARGS__)) +#define ML99_PRIV_variadicsGet_3_IMPL(...) v(ML99_VARIADICS_GET(3)(__VA_ARGS__)) +#define ML99_PRIV_variadicsGet_4_IMPL(...) v(ML99_VARIADICS_GET(4)(__VA_ARGS__)) +#define ML99_PRIV_variadicsGet_5_IMPL(...) v(ML99_VARIADICS_GET(5)(__VA_ARGS__)) +#define ML99_PRIV_variadicsGet_6_IMPL(...) v(ML99_VARIADICS_GET(6)(__VA_ARGS__)) +#define ML99_PRIV_variadicsGet_7_IMPL(...) v(ML99_VARIADICS_GET(7)(__VA_ARGS__)) + +#define ML99_PRIV_VARIADICS_GET_0(...) ML99_PRIV_VARIADICS_GET_AUX_0(__VA_ARGS__, ~) +#define ML99_PRIV_VARIADICS_GET_1(...) ML99_PRIV_VARIADICS_GET_AUX_1(__VA_ARGS__, ~) +#define ML99_PRIV_VARIADICS_GET_2(...) ML99_PRIV_VARIADICS_GET_AUX_2(__VA_ARGS__, ~) +#define ML99_PRIV_VARIADICS_GET_3(...) ML99_PRIV_VARIADICS_GET_AUX_3(__VA_ARGS__, ~) +#define ML99_PRIV_VARIADICS_GET_4(...) ML99_PRIV_VARIADICS_GET_AUX_4(__VA_ARGS__, ~) +#define ML99_PRIV_VARIADICS_GET_5(...) ML99_PRIV_VARIADICS_GET_AUX_5(__VA_ARGS__, ~) +#define ML99_PRIV_VARIADICS_GET_6(...) ML99_PRIV_VARIADICS_GET_AUX_6(__VA_ARGS__, ~) +#define ML99_PRIV_VARIADICS_GET_7(...) ML99_PRIV_VARIADICS_GET_AUX_7(__VA_ARGS__, ~) + +#define ML99_PRIV_VARIADICS_GET_AUX_0(a, ...) a +#define ML99_PRIV_VARIADICS_GET_AUX_1(_a, b, ...) b +#define ML99_PRIV_VARIADICS_GET_AUX_2(_a, _b, c, ...) c +#define ML99_PRIV_VARIADICS_GET_AUX_3(_a, _b, _c, d, ...) d +#define ML99_PRIV_VARIADICS_GET_AUX_4(_a, _b, _c, _d, e, ...) e +#define ML99_PRIV_VARIADICS_GET_AUX_5(_a, _b, _c, _d, _e, f, ...) f +#define ML99_PRIV_VARIADICS_GET_AUX_6(_a, _b, _c, _d, _e, _f, g, ...) g +#define ML99_PRIV_VARIADICS_GET_AUX_7(_a, _b, _c, _d, _e, _f, _g, h, ...) h + +#define ML99_variadicsTail_IMPL(...) v(ML99_VARIADICS_TAIL(__VA_ARGS__)) + +// ML99_variadicsForEach_IMPL { + +#define ML99_variadicsForEach_IMPL(f, ...) \ + ML99_PRIV_CAT(ML99_PRIV_variadicsForEach_, ML99_VARIADICS_IS_SINGLE(__VA_ARGS__)) \ + (f, __VA_ARGS__) +#define ML99_PRIV_variadicsForEach_1(f, x) ML99_appl_IMPL(f, x) +#define ML99_PRIV_variadicsForEach_0(f, x, ...) \ + ML99_TERMS(ML99_appl_IMPL(f, x), ML99_callUneval(ML99_variadicsForEach, f, __VA_ARGS__)) +// } (ML99_variadicsForEach_IMPL) + +// ML99_variadicsForEachI_IMPL { + +#define ML99_variadicsForEachI_IMPL(f, ...) ML99_PRIV_variadicsForEachIAux_IMPL(f, 0, __VA_ARGS__) + +#define ML99_PRIV_variadicsForEachIAux_IMPL(f, i, ...) \ + ML99_PRIV_CAT(ML99_PRIV_variadicsForEachI_, ML99_VARIADICS_IS_SINGLE(__VA_ARGS__)) \ + (f, i, __VA_ARGS__) + +#define ML99_PRIV_variadicsForEachI_1(f, i, x) ML99_appl2_IMPL(f, x, i) +#define ML99_PRIV_variadicsForEachI_0(f, i, x, ...) \ + ML99_TERMS( \ + ML99_appl2_IMPL(f, x, i), \ + ML99_callUneval(ML99_PRIV_variadicsForEachIAux, f, ML99_PRIV_INC(i), __VA_ARGS__)) +// } (ML99_variadicsForEachI_IMPL) + +/* + * The StackOverflow solution: <https://stackoverflow.com/a/2124385/13166656>. + * + * This macro supports at most 63 arguments because C99 allows implementations to handle only 127 + * parameters/arguments per macro definition/invocation (C99 | 5.2.4 Environmental limits), and + * `ML99_PRIV_VARIADICS_COUNT_AUX` already accepts 64 arguments. + */ +// clang-format off +#define ML99_PRIV_VARIADICS_COUNT(...) \ + ML99_PRIV_VARIADICS_COUNT_AUX( \ + __VA_ARGS__, \ + 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, ~) + +#define ML99_PRIV_VARIADICS_COUNT_AUX( \ + _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \ + _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \ + _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, \ + _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, \ + _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, \ + _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, \ + _61, _62, _63, x, ...) \ + x +// clang-format on + +// Arity specifiers { + +#define ML99_variadicsCount_ARITY 1 +#define ML99_variadicsIsSingle_ARITY 1 +#define ML99_variadicsTail_ARITY 1 +#define ML99_variadicsForEach_ARITY 2 +#define ML99_variadicsForEachI_ARITY 2 + +#define ML99_PRIV_variadicsGet_0_ARITY 1 +#define ML99_PRIV_variadicsGet_1_ARITY 1 +#define ML99_PRIV_variadicsGet_2_ARITY 1 +#define ML99_PRIV_variadicsGet_3_ARITY 1 +#define ML99_PRIV_variadicsGet_4_ARITY 1 +#define ML99_PRIV_variadicsGet_5_ARITY 1 +#define ML99_PRIV_variadicsGet_6_ARITY 1 +#define ML99_PRIV_variadicsGet_7_ARITY 1 +// } (Arity specifiers) + +#endif // DOXYGEN_IGNORE + +#endif // ML99_VARIADICS_H |