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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
|
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Macros for parsing and manipulating parameter lists needed for generating
* mocks.
*
* Copyright (C) 2018, Google LLC.
* Author: Brendan Higgins <brendanhiggins@google.com>
*/
#ifndef _TEST_PARAMS_H
#define _TEST_PARAMS_H
#define NUM_VA_ARGS_IMPL(__dummy, \
__1, \
__2, \
__3, \
__4, \
__5, \
__6, \
__7, \
__8, \
__9, \
__10, \
__11, \
__12, \
__13, \
__14, \
__15, \
__16, \
__nargs, args...) __nargs
#define NUM_VA_ARGS(args...) NUM_VA_ARGS_IMPL(__dummy, ##args, \
16, \
15, \
14, \
13, \
12, \
11, \
10, \
9, \
8, \
7, \
6, \
5, \
4, \
3, \
2, \
1, \
0)
#define CONCAT_INTERNAL(left, right) left##right
#define CONCAT(left, right) CONCAT_INTERNAL(left, right)
#define EMPTY()
/*
* Takes the name of a function style macro such as FOO() and prevents it from
* being evaluated on the current pass.
*
* This is useful when you need to write a "recursive" macro since a macro name
* becomes painted after it is pasted. If a different macro is pasted, this
* different macro won't be pasted; if we then defer the evaluation of the this
* "indirection macro", we can prevent the original definition from getting
* painted.
*
* Example:
* #define EXAMPLE EXPAND(FOO()) // FOO() is evaluated on 1st pass.
* #define EXAMPLE EXPAND(DEFER(FOO)()) // FOO() is evaluated on the second
* // pass.
*/
#define DEFER(macro_id) macro_id EMPTY()
/*
* Takes the name of a function style macro such as FOO() and prevents it from
* being evaluated on the current or following pass.
*
* This is useful when you need to DEFER inside an operation which causes an
* extra pass, like IF.
*
* Example:
* #define EXAMPLE EXPAND(FOO()) // FOO() is evaluated on 1st pass.
* #define EXAMPLE EXPAND(DEFER(FOO)()) // FOO() is evaluated on the second
* // pass.
* #define EXAMPLE EXPAND(OBSTRUCT(FOO)()) // FOO() is evaluated on the third
* // pass.
*/
#define OBSTRUCT(macro_id) macro_id DEFER(EMPTY)()
#define EXPAND_1(args...) args
#define EXPAND_2(args...) EXPAND_1(EXPAND_1(args))
#define EXPAND_4(args...) EXPAND_2(EXPAND_2(args))
#define EXPAND_8(args...) EXPAND_4(EXPAND_4(args))
#define EXPAND_16(args...) EXPAND_8(EXPAND_8(args))
/*
* Causes multiple evaluation passes of a macro.
*
* CPP is implemented as a push down automaton. It consumes a stream of tokens
* and as it comes across macros, it either evaluates them and pastes the
* result, or if the macro is a function macro, it pushes the macro to a stack,
* it evaluates the input to the function macro, pops the state from the stack
* and continues.
*
* This macro serves the function of making the cursor return to the beginging
* of a macro that requires mulitple passes to evaluate. It is most useful when
* used with DEFER(...) and OBSTRUCT(...).
*/
#define EXPAND(args...) EXPAND_16(args)
#define INC(id) INC_##id
#define INC_0 1
#define INC_1 2
#define INC_2 3
#define INC_3 4
#define INC_4 5
#define INC_5 6
#define INC_6 7
#define INC_7 8
#define INC_8 9
#define INC_9 10
#define INC_10 11
#define INC_11 12
#define INC_12 13
#define INC_13 14
#define INC_14 15
#define INC_15 16
#define INC_16 17
#define DEC(id) DEC_##id
#define DEC_1 0
#define DEC_2 1
#define DEC_3 2
#define DEC_4 3
#define DEC_5 4
#define DEC_6 5
#define DEC_7 6
#define DEC_8 7
#define DEC_9 8
#define DEC_10 9
#define DEC_11 10
#define DEC_12 11
#define DEC_13 12
#define DEC_14 13
#define DEC_15 14
#define DEC_16 15
#define DROP_FIRST_ARG_INTERNAL(dropped, x, args...) x
#define DROP_FIRST_ARG(args...) DROP_FIRST_ARG_INTERNAL(args)
#define EQUAL(left, right) EQUAL_##left##_##right
#define EQUAL_0_0 dropped, 1
#define EQUAL_1_1 dropped, 1
#define EQUAL_2_2 dropped, 1
#define EQUAL_3_3 dropped, 1
#define EQUAL_4_4 dropped, 1
#define EQUAL_5_5 dropped, 1
#define EQUAL_6_6 dropped, 1
#define EQUAL_7_7 dropped, 1
#define EQUAL_8_8 dropped, 1
#define EQUAL_9_9 dropped, 1
#define EQUAL_10_10 dropped, 1
#define EQUAL_11_11 dropped, 1
#define EQUAL_12_12 dropped, 1
#define EQUAL_13_13 dropped, 1
#define EQUAL_14_14 dropped, 1
#define EQUAL_15_15 dropped, 1
#define EQUAL_16_16 dropped, 1
#define IS_EQUAL(left, right) DROP_FIRST_ARG(EQUAL(left, right), 0)
#define NOT_INTERNAL(condition) NOT_##condition
#define NOT(condition) NOT_INTERNAL(condition)
#define NOT_0 1
#define NOT_1 0
#define IS_NOT_EQUAL(left, right) NOT(IS_EQUAL(left, right))
#define EMPTY_IMPL(tokens) CONCAT(EMPTY_, tokens)
#define IS_EMPTY(tokens)
#define OR_INTERNAL(left, right) OR_##left##_##right
#define OR(left, right) OR_INTERNAL(left, right)
#define OR_0_0 0
#define OR_0_1 1
#define OR_1_0 1
#define OR_1_1 1
#define IF(condition) CONCAT(IF_, condition)
#define IF_0(body)
#define IF_1(body) body
#define COMMA() ,
#define APPLY_TOKENS_INTERNAL(tokens, yield_token, seen_token) \
IF(yield_token)(IF(seen_token)(COMMA()) tokens)
#define APPLY_TOKENS(tokens, yield_token, seen_token) \
APPLY_TOKENS_INTERNAL(tokens, yield_token, seen_token)
/*
* Provides the indirection to keep the PARAM_LIST_RECURSE_INTERNAL from getting
* pasted, only useful if used with DEFER(...) or OBSTRUCT(...).
*/
#define PARAM_LIST_RECURSE_INDIRECT() PARAM_LIST_RECURSE_INTERNAL
/*
* Given a starting index, a number of args, a MACRO to apply, and a list of
* types (with at least one element) this will call MACRO with the first type in
* the list and index; it will then call itself again on all remaining types, if
* any, while incrementing index, and decrementing nargs.
*
* Assumes nargs is the number of types in the list.
*/
#define PARAM_LIST_RECURSE_INTERNAL(index, \
nargs, \
MACRO, \
FILTER, \
context, \
seen_token, \
type, \
args...) \
APPLY_TOKENS(MACRO(context, type, index), \
FILTER(context, type, index), \
seen_token) \
IF(IS_NOT_EQUAL(nargs, 1)) \
(OBSTRUCT(PARAM_LIST_RECURSE_INDIRECT)() \
(INC(index), DEC(nargs), \
MACRO, FILTER, context, \
OR(seen_token, FILTER(context, type, index)), \
args))
#define PARAM_LIST_RECURSE(index, nargs, MACRO, FILTER, context, args...) \
IF(IS_NOT_EQUAL(nargs, 0)) \
(OBSTRUCT(PARAM_LIST_RECURSE_INTERNAL)(index, \
nargs, \
MACRO, \
FILTER, \
context, \
0, \
args))
#define FILTER_NONE(context, type, index) 1
#define FILTER_INDEX_INTERNAL(index_to_drop, type, index) \
IS_NOT_EQUAL(index, index_to_drop)
#define FILTER_INDEX(index_to_drop, type, index) \
FILTER_INDEX_INTERNAL(index_to_drop, type, index)
/*
* Applies a MACRO which takes a type and the index of the type and outputs a
* sequence of tokens to a list of types.
*/
#define FOR_EACH_PARAM(MACRO, FILTER, context, args...) \
EXPAND(PARAM_LIST_RECURSE(0,\
NUM_VA_ARGS(args),\
MACRO,\
FILTER,\
context,\
args))
#define PRODUCE_TYPE_AND_ARG(context, type, index) type arg##index
#define PARAM_LIST_FROM_TYPES(args...) \
FOR_EACH_PARAM(PRODUCE_TYPE_AND_ARG, \
FILTER_NONE, \
not_used, \
args)
#define PRODUCE_TYPE_NAME(context, type, index) #type
#define TYPE_NAMES_FROM_TYPES(handle_index, args...) \
FOR_EACH_PARAM(PRODUCE_TYPE_NAME, \
FILTER_INDEX, \
handle_index, \
args)
#define PRODUCE_PTR_TO_ARG(context, type, index) &arg##index
#define PTR_TO_ARG_FROM_TYPES(handle_index, args...) \
FOR_EACH_PARAM(PRODUCE_PTR_TO_ARG, \
FILTER_INDEX, \
handle_index, \
args)
#define PRODUCE_MATCHER_AND_ARG(ctrl_index, type, index) \
IF(IS_EQUAL(index, ctrl_index))(struct mock *arg##ctrl_index) \
IF(IS_NOT_EQUAL(index, ctrl_index))( \
struct mock_param_matcher *arg##index)
#define MATCHER_PARAM_LIST_FROM_TYPES(ctrl_index, args...) \
FOR_EACH_PARAM(PRODUCE_MATCHER_AND_ARG, \
FILTER_NONE, \
ctrl_index, \
args)
#define PRODUCE_ARG(context, type, index) arg##index
#define ARG_NAMES_FROM_TYPES(ctrl_index, args...) \
FOR_EACH_PARAM(PRODUCE_ARG, \
FILTER_INDEX, \
ctrl_index, \
args)
#define PRODUCE_ARRAY_ACCESSOR(context, type, index) *((type *) params[index])
#define ARRAY_ACCESSORS_FROM_TYPES(args...) \
FOR_EACH_PARAM(PRODUCE_ARRAY_ACCESSOR, \
FILTER_NONE, \
not_used, \
args)
#endif /* _TEST_PARAMS_H */
|