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
|
// Copyright (C) 2009-2012 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0
// (see accompanying file LICENSE_1_0.txt or a copy at
// http://www.boost.org/LICENSE_1_0.txt)
// Home at http://www.boost.org/libs/local_function
#ifndef BOOST_LOCAL_FUNCTION_AUX_NAME_HPP_
#define BOOST_LOCAL_FUNCTION_AUX_NAME_HPP_
#include <boost/local_function/config.hpp>
#include <boost/local_function/aux_/macro/decl.hpp>
#include <boost/local_function/aux_/macro/code_/functor.hpp>
#include <boost/local_function/detail/preprocessor/keyword/recursive.hpp>
#include <boost/local_function/detail/preprocessor/keyword/inline.hpp>
#include <boost/local_function/aux_/function.hpp>
#include <boost/local_function/aux_/symbol.hpp>
#include <boost/preprocessor/control/iif.hpp>
#include <boost/preprocessor/control/expr_iif.hpp>
#include <boost/preprocessor/logical/bitor.hpp>
#include <boost/preprocessor/tuple/eat.hpp>
// PRIVATE //
#define BOOST_LOCAL_FUNCTION_AUX_NAME_LOCAL_TYPE_(local_function_name) \
BOOST_LOCAL_FUNCTION_AUX_SYMBOL( (local_type)(local_function_name) )
#define BOOST_LOCAL_FUNCTION_AUX_NAME_INIT_RECURSION_FUNC_ \
BOOST_LOCAL_FUNCTION_AUX_SYMBOL( (init_recursion) )
#define BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_FUNC_( \
is_recursive, local_function_name) \
BOOST_PP_IIF(is_recursive, \
local_function_name \
, \
BOOST_LOCAL_FUNCTION_AUX_SYMBOL( (nonrecursive_local_function_name) ) \
)
#define BOOST_LOCAL_FUNCTION_AUX_NAME_END_LOCAL_FUNCTOR_(typename01, \
local_function_name, is_recursive, \
local_functor_name, nonlocal_functor_name) \
/* FUNCTION macro expanded to: typedef class functor ## __LINE__ { ... */ \
BOOST_PP_EXPR_IIF(is_recursive, \
/* member var with function name for recursive calls; it cannot be */ \
/* `const` because it is init after construction (because */ \
/* constructor doesn't know local function name) */ \
/* run-time: even when optimizing, recursive calls cannot be */ \
/* optimized (i.e., they must be via the non-local functor) */ \
/* because this cannot be a mem ref because its name is not known */ \
/* by the constructor so it cannot be set by the mem init list */ \
private: \
BOOST_LOCAL_FUNCTION_AUX_CODE_FUNCTOR_TYPE \
BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_FUNC_(is_recursive, \
local_function_name); \
/* run-time: the `init_recursion()` function cannot be called */ \
/* by the constructor to allow for compiler optimization */ \
/* (inlining) so it must be public to be called (see below) */ \
public: \
inline void BOOST_LOCAL_FUNCTION_AUX_NAME_INIT_RECURSION_FUNC_( \
BOOST_LOCAL_FUNCTION_AUX_CODE_FUNCTOR_TYPE& functor) { \
local_function_name = functor; \
} \
) \
} BOOST_LOCAL_FUNCTION_AUX_NAME_LOCAL_TYPE_(local_function_name); \
/* local functor can be passed as tparam only on C++11 (faster) */ \
BOOST_LOCAL_FUNCTION_AUX_NAME_LOCAL_TYPE_(local_function_name) \
local_functor_name(BOOST_LOCAL_FUNCTION_AUX_DECL_ARGS_VAR.value); \
/* non-local functor can always be passed as tparam (but slower) */ \
BOOST_PP_EXPR_IIF(typename01, typename) \
BOOST_LOCAL_FUNCTION_AUX_NAME_LOCAL_TYPE_(local_function_name):: \
BOOST_LOCAL_FUNCTION_AUX_CODE_FUNCTOR_TYPE \
nonlocal_functor_name; /* functor variable */ \
/* the order of the following 2 function calls cannot be changed */ \
/* because init_recursion uses the local_functor so the local_functor */ \
/* must be init first */ \
local_functor_name.BOOST_LOCAL_FUNCTION_AUX_FUNCTION_INIT_CALL_FUNC( \
&local_functor_name, nonlocal_functor_name); \
BOOST_PP_EXPR_IIF(is_recursive, \
/* init recursion causes MSVC to not optimize local function not */ \
/* even when local functor is used as template parameter so no */ \
/* recursion unless all inlining optimizations are specified off */ \
local_functor_name.BOOST_LOCAL_FUNCTION_AUX_NAME_INIT_RECURSION_FUNC_( \
nonlocal_functor_name); \
)
#define BOOST_LOCAL_FUNCTION_AUX_NAME_FUNCTOR_(local_function_name) \
BOOST_LOCAL_FUNCTION_AUX_SYMBOL( (local_function_name) )
// This can always be passed as a template parameters (on all compilers).
// However, it is slower because it cannot be inlined.
// Passed at tparam: Yes (on all C++). Inlineable: No. Recursive: No.
#define BOOST_LOCAL_FUNCTION_AUX_NAME_(typename01, local_function_name) \
BOOST_LOCAL_FUNCTION_AUX_NAME_END_LOCAL_FUNCTOR_(typename01, \
local_function_name, \
/* local function is not recursive (because recursion and its */ \
/* initialization cannot be inlined even on C++11, */ \
/* so this allows optimization at least on C++11) */ \
0 /* not recursive */ , \
/* local functor */ \
BOOST_LOCAL_FUNCTION_AUX_NAME_FUNCTOR_(local_function_name), \
/* local function declared as non-local functor -- but it can */ \
/* be inlined only by C++11 and it cannot be recursive */ \
local_function_name)
// This is faster on some compilers but not all (e.g., it is faster on GCC
// because its optimization inlines it but not on MSVC). However, it cannot be
// passed as a template parameter on non C++11 compilers.
// Passed at tparam: Only on C++11. Inlineable: Yes. Recursive: No.
#define BOOST_LOCAL_FUNCTION_AUX_NAME_INLINE_(typename01, local_function_name) \
BOOST_LOCAL_FUNCTION_AUX_NAME_END_LOCAL_FUNCTOR_(typename01, \
local_function_name, \
/* inlined local function is never recursive (because recursion */ \
/* and its initialization cannot be inlined)*/ \
0 /* not recursive */ , \
/* inlined local function declared as local functor (maybe */ \
/* inlined even by non C++11 -- but it can be passed as */ \
/* template parameter only on C++11 */ \
local_function_name, \
/* non-local functor */ \
BOOST_LOCAL_FUNCTION_AUX_NAME_FUNCTOR_(local_function_name))
// This is slower on all compilers (C++11 and non) because recursion and its
// initialization can never be inlined.
// Passed at tparam: Yes. Inlineable: No. Recursive: Yes.
#define BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_( \
typename01, local_function_name) \
BOOST_LOCAL_FUNCTION_AUX_NAME_END_LOCAL_FUNCTOR_(typename01, \
local_function_name, \
/* recursive local function -- but it cannot be inlined */ \
1 /* recursive */ , \
/* local functor */ \
BOOST_LOCAL_FUNCTION_AUX_NAME_FUNCTOR_(local_function_name), \
/* local function declared as non-local functor -- but it can */ \
/* be inlined only by C++11 */ \
local_function_name)
// Inlined local functions are specified by `..._NAME(inline name)`.
// They have more chances to be inlined for faster run-times by some compilers
// (for example by GCC but not by MSVC). C++11 compilers can always inline
// local functions even if they are not explicitly specified inline.
#define BOOST_LOCAL_FUNCTION_AUX_NAME_PARSE_INLINE_( \
typename01, qualified_name) \
BOOST_PP_IIF(BOOST_PP_BITOR( \
BOOST_LOCAL_FUNCTION_CONFIG_LOCALS_AS_TPARAMS, \
BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_IS_INLINE_FRONT( \
qualified_name)), \
/* on C++11 always use inlining because compilers might optimize */ \
/* it to be faster and it can also be passed as tparam */ \
BOOST_LOCAL_FUNCTION_AUX_NAME_INLINE_ \
, \
/* on non C++11 don't use liniling unless explicitly specified by */ \
/* programmers `inline name` the inlined local function cannot be */ \
/* passed as tparam */ \
BOOST_LOCAL_FUNCTION_AUX_NAME_ \
)(typename01, BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_INLINE_REMOVE_FRONT( \
qualified_name))
// Expand to 1 iff `recursive name` or `recursive inline name` or
// `inline recursive name`.
#define BOOST_LOCAL_FUNCTION_AUX_NAME_IS_RECURSIVE_(qualified_name) \
BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_IS_RECURSIVE_FRONT( \
BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_INLINE_REMOVE_FRONT( \
qualified_name \
))
// Revmoes `recursive`, `inline recursive`, and `recursive inline` from front.
#define BOOST_LOCAL_FUNCTION_AUX_NAME_REMOVE_RECURSIVE_AND_INLINE_( \
qualified_name) \
BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_RECURSIVE_REMOVE_FRONT( \
BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_INLINE_REMOVE_FRONT( \
BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_RECURSIVE_REMOVE_FRONT( \
qualified_name \
)))
#define BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_REMOVE_(qualified_name) \
BOOST_PP_IIF(BOOST_LOCAL_FUNCTION_AUX_NAME_IS_RECURSIVE_(qualified_name), \
BOOST_LOCAL_FUNCTION_AUX_NAME_REMOVE_RECURSIVE_AND_INLINE_ \
, \
qualified_name /* might be `name` or `inline name` */ \
BOOST_PP_TUPLE_EAT(1) \
)(qualified_name)
// Recursive local function are specified by `..._NAME(recursive name)`.
// They can never be inlined for faster run-time (not even by C++11 compilers).
#define BOOST_LOCAL_FUNCTION_AUX_NAME_PARSE_RECURSIVE_( \
typename01, qualified_name) \
BOOST_PP_IIF(BOOST_LOCAL_FUNCTION_AUX_NAME_IS_RECURSIVE_(qualified_name), \
/* recursion can never be inlined (not even on C++11) */ \
BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_ \
, \
BOOST_LOCAL_FUNCTION_AUX_NAME_PARSE_INLINE_ \
)(typename01, \
BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_REMOVE_(qualified_name))
// PUBLIC //
#define BOOST_LOCAL_FUNCTION_AUX_NAME(typename01, qualified_name) \
BOOST_LOCAL_FUNCTION_AUX_NAME_PARSE_RECURSIVE_(typename01, qualified_name)
#endif // #include guard
|
