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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
/*=============================================================================
Boost.Wave: A Standard compliant C++ preprocessor library
http://www.boost.org/
Copyright (c) 2001-2005 Hartmut Kaiser. Distributed under the Boost
Software License, Version 1.0. (See accompanying file
LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
// Tests more complex macro expansion.
// token-pasting macro
#define CAT(a, b) PRIMITIVE_CAT(a, b)
#define PRIMITIVE_CAT(a, b) a ## b
// splits a value that is about to expand into two parameters and returns
// either the zero-th or one-th element.
#define SPLIT(n, im) PRIMITIVE_CAT(SPLIT_, n)(im)
#define SPLIT_0(a, b) a
#define SPLIT_1(a, b) b
// detects if the parameter is nullary parentheses () or something else.
// passing non-nullary parenthesis is invalid input.
#define IS_NULLARY(expr) \
SPLIT( \
0, \
CAT(IS_NULLARY_R_, IS_NULLARY_T expr) \
) \
/**/
#define IS_NULLARY_T() 1
#define IS_NULLARY_R_1 1, ?
#define IS_NULLARY_R_IS_NULLARY_T 0, ?
// expands to a macro that eats an n-element parenthesized expression.
#define EAT(n) PRIMITIVE_CAT(EAT_, n)
#define EAT_0()
#define EAT_1(a)
#define EAT_2(a, b)
#define EAT_3(a, b, c)
// expands to a macro that removes the parentheses from an n-element
// parenthesized expression
#define REM(n) PRIMITIVE_CAT(REM_, n)
#define REM_0()
#define REM_1(a) a
#define REM_2(a, b) a, b
#define REM_3(a, b, c) a, b, c
// expands to nothing
#define NIL
// expands to 1 if x is less than y otherwise, it expands to 0
#define LESS(x, y) \
IS_NULLARY( \
PRIMITIVE_CAT(LESS_, y)( \
EAT(1), PRIMITIVE_CAT(LESS_, x) \
)() \
) \
/**/
#define LESS_0(a, b) a(EAT(2)) b(REM(1), NIL)
#define LESS_1(a, b) a(LESS_0) b(REM(1), NIL)
#define LESS_2(a, b) a(LESS_1) b(REM(1), NIL)
#define LESS_3(a, b) a(LESS_2) b(REM(1), NIL)
#define LESS_4(a, b) a(LESS_3) b(REM(1), NIL)
#define LESS_5(a, b) a(LESS_4) b(REM(1), NIL)
// expands to the binary one's compliment of a binary input value. i.e. 0 or 1
#define COMPL(n) PRIMITIVE_CAT(COMPL_, n)
#define COMPL_0 1
#define COMPL_1 0
// these do the obvious...
#define GREATER(x, y) LESS(y, x)
#define LESS_EQUAL(x, y) COMPL(LESS(y, x))
#define GREATER_EQUAL(x, y) COMPL(LESS(x, y))
// causes another rescan...
#define SCAN(x) x
// expands to 1 if x is not equal to y. this one contains a workaround...
#define NOT_EQUAL(x, y) \
IS_NULLARY( \
SCAN( \
PRIMITIVE_CAT(LESS_, x)( \
EAT(1), \
PRIMITIVE_CAT(LESS_, y) EAT(2) \
)((), ...) \
) \
) \
/**/
#define EQUAL(x, y) COMPL(NOT_EQUAL(x, y))
//R #line 95 "t_1_024.cpp"
LESS(2, 3) //R 1
LESS(3, 2) //R 0
LESS(3, 3) //R 0
GREATER(2, 3) //R 0
GREATER(3, 2) //R 1
GREATER(3, 3) //R 0
LESS_EQUAL(2, 3) //R 1
LESS_EQUAL(3, 2) //R 0
LESS_EQUAL(3, 3) //R 1
GREATER_EQUAL(2, 3) //R 0
GREATER_EQUAL(3, 2) //R 1
GREATER_EQUAL(3, 3) //R 1
NOT_EQUAL(2, 3) //R 1
NOT_EQUAL(3, 2) //R 1
NOT_EQUAL(3, 3) //R 0
EQUAL(2, 3) //R 0
EQUAL(3, 2) //R 0
EQUAL(3, 3) //R 1
|
