Compare commits

...

406 Commits

Author SHA1 Message Date
667e87b339 Change C test names to not conflict with the C++ ones 2022-08-16 20:59:52 +03:00
e919b652af Disable __VA_OPT__ on g++ 8/9 in c++2a mode, as vaopt.cpp fails 2022-08-16 19:09:04 +03:00
108a948323 Add .github/workflows 2022-08-16 11:31:06 +03:00
eacc296fa5 Merge branch 'master' into develop 2022-08-16 11:27:43 +03:00
d4e82d7d3f Merge branch 'develop' 2021-06-27 13:24:38 -04:00
69614bb1da Fix CMake tests in .travis.yml 2021-06-10 16:37:10 +03:00
24abbdc906 Update CMakeLists.txt 2021-06-10 02:09:03 +03:00
45178c3cc5 Merge branch 'master' into develop 2021-06-10 02:07:17 +03:00
93b896c932 Corrected cmake tests 2021-05-29 08:59:36 -04:00
229f654b59 Merge branch 'develop' 2021-02-15 16:07:36 -05:00
aa8f347df2 Treat nvcc compiling in cuda mode with _MSC_VER defined as if it is the VC++ default preprocessor as far as variadic macro support is concerned. 2021-02-11 23:38:30 -05:00
d8471d6526 Merge pull request #36 from sdarwin/drone
Drone config
2021-01-13 12:42:59 -05:00
bee33b0117 add drone config [ci skip] 2021-01-13 17:09:26 +00:00
b49e14231f Merge branch 'develop' 2020-12-29 16:26:32 -05:00
5289c50299 Update meta information 2020-12-28 10:15:43 -05:00
5e17804af2 Merge branch 'develop' 2020-10-25 06:16:15 -04:00
15dcb92ebf Revert "Chyange number of jobs to use $nproc"
This reverts commit 112673238a.
2020-10-25 06:15:04 -04:00
ae5e475169 Merge branch 'develop' 2020-10-24 20:35:07 -04:00
112673238a Chyange number of jobs to use $nproc 2020-10-24 20:33:54 -04:00
bff73def85 Remove preprocessor limits CI testing 2020-09-25 12:47:54 -04:00
5e2770334d Address model for msvc-10 and msvc-11 must be only 32-bit in appveyor.yml 2020-09-25 11:18:29 -04:00
e4186a6df1 Updated appveyor tests 2020-09-22 19:33:56 -04:00
4a274cbe86 Corrected msvc-14.0 setup 2020-09-22 13:24:12 -04:00
7bed5072e4 Update on config.hpp so we are not redefining a defined macro. 2020-09-22 00:30:33 -04:00
b3f95b899f More individual travis ci preprocessor limits tests. 2020-09-21 18:39:06 -04:00
8f937e431e More individual appveyor preprocessor limits tests. 2020-09-20 17:26:49 -04:00
879e876d45 Add address-model for limits build in Travis CI 2020-09-20 06:15:41 -04:00
1a2e813fcb Corrected Travis CI syntax 2020-09-20 05:38:29 -04:00
5a30bc472d Updated Appveyor setup. 2020-09-20 00:52:01 -04:00
d12d2d9a3a Updated .yml files 2020-09-19 23:02:30 -04:00
2ab48feed5 Corrected syntax 2020-09-19 19:46:58 -04:00
6ec9072f27 Update yml to handle Boost Build bug with explicit alias when not invoking b2 from the test directory. 2020-09-19 17:46:22 -04:00
cac5e3e2ef Rearrangement of links and better explanation of variadic macro support. 2020-09-19 09:14:26 -04:00
4b1d674a17 Updated title page specifying assumption of variadic macro support. 2020-09-19 07:59:43 -04:00
9fcd0a289a Upgrade docs to say that variadic macros must be supported by the compiler. 2020-09-19 02:24:44 -04:00
5fd12d32d4 Assume variadic macro support. 2020-09-17 18:25:36 -04:00
8288ce7575 Updated limitations docs. 2020-09-14 18:26:49 -04:00
ae836b12e4 Updated appveyor which protects b2 parameter by putting it within quote marks. 2020-09-14 15:43:10 -04:00
fe22f14954 Fixed check by not omitting the 0 check. 2020-09-04 17:38:08 -04:00
322e4266fb Reinstalled Intel on Windows fix fgor 17.0 on up. 2020-09-02 04:14:49 -04:00
f74e04f827 Fixed tests for non-strict compilers. 2020-09-02 01:37:00 -04:00
1ace1d3806 Fixed syntax error of a missing #endif 2020-09-01 21:08:13 -04:00
ed066d3c81 Further separation to strict and non-strict implementations in variadic implementations. 2020-09-01 19:31:41 -04:00
96e994a25a Further separation to strict and non-strict implementations in tuple implementations. 2020-09-01 19:19:23 -04:00
ac553f44fb Further separation to strict and non-strict implementations in seq implementations. 2020-09-01 16:03:28 -04:00
b93e99332b Further separation to strict and non-strict implementations in logical and repetition implementations. 2020-09-01 08:30:03 -04:00
001d109eab Further separation to strict and non-strict implementations in list implementations. 2020-09-01 02:50:29 -04:00
fedfdc2f32 Further separation to strict and non-strict implementations. 2020-09-01 00:35:19 -04:00
775f9eb24e Further separation to strict and non-strict implementations. 2020-08-31 21:08:44 -04:00
9b8138324f Changed separation to strict and non-strict implementations and include only the header files needed by either. 2020-08-31 16:51:00 -04:00
158fc13f01 Changed separation to strict and non-strict implementations and include only the header files needed by either. 2020-08-31 16:38:03 -04:00
721ef44e79 Revert arithmetic changes to original for msvc default preprocessor. 2020-08-31 10:55:17 -04:00
c1eb9292d7 Removed BOOST_PP_CAT workaround for Intel compiler on Windows for version 18.0 and above, as it was causing a failure in preprocessor tests. 2020-08-30 15:07:31 -04:00
d49db1ef09 Testing preprocessor limits in CI 2020-08-28 14:37:49 -04:00
92ac085edf Updated for new VC++ preprocessor, explicit tests, address model, and cxxstd. 2020-08-28 01:00:37 -04:00
fe67cda385 Create explicit tests for the limitation tests. 2020-08-28 00:59:47 -04:00
a1303d0763 Fixed erroneous extra #endif 2020-08-27 01:35:33 -04:00
5c83504677 Merge branch 'develop' into expand_number
# Conflicts:
#	include/boost/preprocessor/variadic/size.hpp
#	test/seq.cxx
#	test/variadic.cxx
2020-08-27 00:46:34 -04:00
b0a0bb281c Reinstituted a test. 2020-08-26 21:51:08 -04:00
661aa5c36e Cleanmer variadic size implementation. 2020-08-26 21:49:21 -04:00
a9ed92efbd Updates for empty variadic data. 2020-08-26 17:47:07 -04:00
f977ee0cd9 Updated the docs for limitations. 2020-08-23 20:12:06 -04:00
5d70c1fc7b Corrected limit. Added BOOST_PP_IS_STANDARD macro. Updated variadic tests. 2020-08-23 20:08:38 -04:00
1cf82f9928 Separate variadic and tuple limits so that variadic limits can be greater. 2020-08-17 21:22:13 -04:00
59cdb3e5db Updated limits and corrected deduce_r. 2020-08-16 11:20:25 -04:00
2c20e742a1 Merge branch 'develop' into master 2020-08-14 19:42:33 -04:00
4afae94309 Updated tests for clang 2020-08-14 19:38:55 -04:00
44a4e07994 Fix non-variadic tuple elem access. 2020-08-13 01:38:33 -04:00
3f43be5b55 Limited fold_left invocations. 2020-08-12 12:32:57 -04:00
d86d461aa7 Corrected seq's fold_left. 2020-08-11 22:13:23 -04:00
45565b6dc3 Updated tests for VC++ deficiencies. 2020-08-11 10:26:13 -04:00
1fe79acc20 Updated list tests 2020-08-10 21:11:57 -04:00
ff9d451901 Added selection tests. 2020-08-09 11:09:50 -04:00
e7b1f71c7e Updated tests and doc fix. 2020-08-08 11:30:37 -04:00
e44c47c9c3 Merge pull request #32 from jwakely/develop
Fix invalid XHTML document
2020-08-05 09:33:41 -04:00
0e1a2fecb1 Fix invalid XHTML document 2020-08-05 10:40:01 +01:00
c5fe11a649 Updated comparisons for 1024 maximum. 2020-08-01 17:57:02 -04:00
ee0c4135c3 Updated arithmetic tests for 1024 max. 2020-07-31 23:41:43 -04:00
2fb4b3de1b Iteration limit to 1024. 2020-07-28 20:36:00 -04:00
585fad5198 Fix dec limits. Allow 1024 in number and seq limits. 2020-07-28 01:39:40 -04:00
21f796567e Add 1024 limit for all related number functionality 2020-07-27 20:59:29 -04:00
905520aaf8 Added 1024 as maximum number 2020-07-27 07:54:05 -04:00
ea15d11d2f Updated iteration tests for 512 maximum 2020-07-25 12:43:39 -04:00
42a283d112 Repetition tests when exceeding the 256 minimum number of repetitions 2020-07-19 17:30:40 -04:00
aba61d6018 Rename to all lower case. 2020-07-14 17:52:41 -04:00
572f3f4d4a Fixed syntax error. 2020-07-14 17:39:48 -04:00
6272649c8f Allow macro to be passed only tuple, without the tuple size, when variadics are used. 2020-07-14 17:34:17 -04:00
efe8cb6242 Updated list tests 2020-07-12 19:06:21 -04:00
a03dd0419e Fix syntax error 2020-07-12 19:05:57 -04:00
9ba4469131 Fixed size implementation. 2020-07-11 13:51:08 -04:00
7e3516eb8f Revert "Revert to original size implementation now that 'while' has been expanded by one iteration."
This reverts commit 7e30c606b7.
2020-07-11 13:46:35 -04:00
7e30c606b7 Revert to original size implementation now that 'while' has been expanded by one iteration. 2020-07-11 11:05:21 -04:00
28a0c21651 Maximum for loop 2020-07-11 05:04:00 -04:00
0fbfe9c981 Increased while loops by one to encompass maximum numbers. 2020-07-10 23:06:27 -04:00
c8e005f696 Corrected fold_left to allow for maximum tests. 2020-07-10 12:19:38 -04:00
74f652c85f Updated size. 2020-07-08 22:04:07 -04:00
b9424eac02 Revert back to original reverse implementation 2020-07-07 20:23:58 -04:00
f10c669bab Add more large list tests 2020-07-07 19:13:37 -04:00
0fd6b84304 Add extra iteration for fold_left and fold_right to cover maximum operations. 2020-07-07 19:13:05 -04:00
db21240060 Split reverse for seq seize greater than 256 2020-07-05 13:13:06 -04:00
14a263bf9d Updated to not do duplicate dec 2020-07-05 10:57:18 -04:00
5c7ae49828 Updated doc doe BOOST_PP_OVERLOAD. 2020-07-03 14:18:44 -04:00
bb9d4273d4 Updated seq tests 2020-07-02 18:39:04 -04:00
110ddaca75 Updated tests. 2020-07-02 15:07:17 -04:00
5e74d9f12e Added config.hpp back. 2020-07-02 12:13:22 -04:00
1b5c17f75b Updated header includes 2020-07-02 11:36:36 -04:00
15d0d66a75 Updated limit implementation. 2020-07-02 11:24:15 -04:00
e231fe7ad9 Updated docs for the the fact that in C++20 mode when __VA_OPT__ is supported variadic data passed some of the variadic macros can be empty. 2020-06-30 14:50:47 -04:00
a037024cec Updated Travis CI clang 9 and 10 configurations 2020-06-30 13:32:30 -04:00
57c160f921 Updated travis CI tests 2020-06-30 10:55:50 -04:00
3ac4c915a3 In C++20 variadic data can be empty. This means that BOOST_PP_VARIADIC_SIZE now returns 0 for empty data instead of 1, and that conversions to and from empty variadic data and lists or arrays, which can be empty, work properly. 2020-06-29 21:57:23 -04:00
47b430e3d5 Updated limits need undefs. Break reverse into two eequal parts. Updated seq tests. 2020-06-28 12:52:41 -04:00
59048974ba When the tuple limit is not 256, use previous implementation 2020-06-13 13:19:21 -04:00
62da4cc84b Updated tests. 2020-06-13 04:01:22 -04:00
b72dcd7958 Fixed array functionality for large arrays. 2020-06-11 20:44:39 -04:00
cf34b5c21b Simplified functionality 2020-06-11 08:23:22 -04:00
1347313cae Added copyright 2020-06-11 08:22:46 -04:00
31704b522a Added copyrights 2020-06-11 08:22:00 -04:00
f16f7721b5 Corrected syntax errors 2020-06-11 08:20:53 -04:00
43f02f9405 Simplified multiplication 2020-06-10 11:05:43 -04:00
e8bbb16f57 Use detail check for number 1 rather than empty implementation. 2020-06-10 10:44:35 -04:00
25aaea0136 Updated arithmetic. 2020-06-10 09:59:30 -04:00
13c9669410 Updated arithmetic implementations to deal with corner cases whichy run out of WHILE loops. 2020-06-09 20:54:12 -04:00
d41d1dda97 Updated multiplication and subtraction to check for maximum/minimum numbers. 2020-06-07 15:49:53 -04:00
c07bb185c1 Updated BOOST_PP_ADD implementation checking for the maximum number. 2020-06-07 05:36:32 -04:00
43caf4d41e Added macros for testing miniumum (0) andf maximum numbers. 2020-06-06 16:12:56 -04:00
a6c5cd5bcf Update test and jamfile 2020-06-04 21:52:46 -04:00
05b3defe2f Update arithmetic tests 2020-05-29 21:35:40 -04:00
d49211a963 Only allow limits to be used by strictly conforming compilers. 2020-05-29 21:35:08 -04:00
7541c351ce Update variadics test. 2020-05-29 13:12:53 -04:00
b68a2409ad Fix syntax errors. 2020-05-29 13:11:46 -04:00
0999dfe1d5 Update default list size from 255 to 256. 2020-05-29 13:11:04 -04:00
a7560df684 Adding limits for repetition and seq. 2020-05-19 15:35:54 -04:00
efa576203b Testing of numbers up to 512 2020-05-09 17:03:48 -04:00
fd3b57b15a Added arithmetic testing for numbers up to 512. Corrected seq macro which does not expect a number above 256. 2020-05-04 18:44:20 -04:00
c859da1fc9 Fixed some syntax errors and updated a test to asccount for numbers being more than 256. 2020-05-04 00:34:09 -04:00
efea46b2fb Allow iteration limits to be configured 2020-05-03 22:31:58 -04:00
b95d91ee71 Use a separate BOOST_PP_LIMIT_VARIADIC for variadic elements 2020-05-03 14:35:41 -04:00
9bf0043260 Updates for tuple elements of more than 64 elements 2020-05-02 21:59:30 -04:00
533d636ece Implement tuple limits for TUPLE functionality. Add updated copyright for changed files. 2020-05-01 14:38:32 -04:00
0dcaaac66f Changed directory structure so that all limits implementations are in their own relative "limits" subdirectory. 2020-04-30 10:24:33 -04:00
3b6102cd03 Added ability to change the number of tuple elements. A number of small fixes. 2020-04-30 09:06:06 -04:00
82addd1b28 Support for expanded numbers up to 512, as well as expanded while iterationms up to 512. 2020-04-29 06:38:10 -04:00
ffb26db146 Not going to test msvc-9,0 anymore. It is just too old and I can not test it locally. 2020-04-26 09:38:05 -04:00
e4fb5f4866 Merge branch 'develop' 2020-03-01 00:18:20 -05:00
9cf66925d4 Latest Borland with clang can support variadic macros. Updated iso test to be more correct choosing compiler level. 2020-02-18 02:44:51 -05:00
e4ce0f06f5 Merge branch 'develop' 2020-02-01 23:12:13 -05:00
98f6c75e1e Make the quick.cpp test 'explicit'. 2020-01-06 02:34:42 -05:00
f99ed9921a Merge pull request #28 from boostorg/feature/add-cmake-tests
Add CMake install support, tests
2020-01-05 20:20:29 -05:00
a378d239da Disable the Appveyor cmake_test configuration on 2015/2017 as it's too slow; only bootstrap b2 in the boost_build_test configuration 2020-01-05 07:19:59 +02:00
0332a793f5 Fix Appveyor branch handling 2020-01-05 06:48:21 +02:00
6c350c6fc3 Update appveyor.yml 2020-01-05 06:46:08 +02:00
728c71ba75 Enable C in test/CMakeLists.txt; add int main() {} to quick.cpp 2020-01-05 05:07:08 +02:00
1ab9385a91 Add CMake install support, tests 2020-01-05 04:32:16 +02:00
688c3f2ee6 Turn off variadic macro support by default for nvcc only when compiling CUDA files. 2019-12-14 13:20:45 -05:00
bd0db5ce8b Changed __CUDACC__ to __NVCC__ as other compilers do define __CUDACC__ when compiling CUDA files. 2019-12-14 12:45:02 -05:00
da60e76913 Added 'explicit' for test_iso. 2019-11-13 20:45:02 -05:00
661dd91603 Added explicit test with the alias 'test_iso' to run tests for macro expansion for the various C++ standards. 2019-11-13 20:38:10 -05:00
ffb27a1d56 Merge branch 'develop' 2019-11-12 15:01:45 -05:00
a6404a8fb2 Fixed __VA_OPT__ functionality for vc++ in c20 mode. 2019-11-12 14:57:09 -05:00
732d00341f For the default VC++ preprocessor turn off __VA_OPT__ support in true c20 mode ( /Zc:__cplusplus ) as it can not handle it. 2019-11-12 10:31:24 -05:00
e7256313c4 Merge branch 'develop' 2019-11-03 23:32:49 -05:00
b3036f1a63 Expanded emptiness explanation with the addition of the BOOST_PP_VA_OPT macro. 2019-11-02 23:58:29 -04:00
de49676452 Added docs for the BOOST_PP_VA_OPT macro. 2019-11-02 18:59:55 -04:00
4f4f04c56b Added va_opt.hpp to facilities header file. 2019-11-01 15:51:34 -04:00
c5e90f23b7 Updated check_empty variadic macro notation. 2019-11-01 15:34:08 -04:00
776037ae56 Corrected implementation and testing for BOOST_PP_VA_OPT 2019-10-31 06:07:10 -04:00
a9827c8fc8 Updated docs __VA_OPT__ support. 2019-10-30 14:32:45 -04:00
6db241a78d Merge remote-tracking branch 'remotes/origin/develop' 2019-10-20 17:03:23 -04:00
4fe7807f79 Add BOOST_PP_VA_OPT implementation 2019-10-20 17:00:51 -04:00
80107ea60a Changed opt to has_opt in header file and HTML 2019-10-19 10:51:40 -04:00
1473215dc7 Changed name of macro from BOOST_PP_VARIADIC_OPT to BOOST_PP_VARIADIC_HAS_OPT 2019-10-19 05:49:13 -04:00
291f92696d Merge branch 'develop' 2019-10-09 12:48:38 -04:00
771edacbff Completed the emptiness topic. 2019-10-08 15:50:08 -04:00
ac99242b71 Add a topic on "emptiness" 2019-10-08 09:43:18 -04:00
bda6ad9148 Updated docs 2019-10-06 22:20:19 -04:00
88a0365f4d Added the BOOST_PP_CHECK_EMPTY macro and documentation. 2019-10-06 22:06:38 -04:00
6af29d8b77 Merge branch 'develop' 2019-10-04 22:51:14 -04:00
af70b2872e Updated for compiling a CUDA file with clang. 2019-10-02 18:52:09 -04:00
b7b1425c7f Remove duplicate printing of a macro in this test. 2019-09-28 11:25:09 -04:00
54669af127 Fixed macro testing for __VA_OPT__ support. 2019-09-27 22:15:18 -04:00
e439b2555e Updated name and parameters for clang cuda test. 2019-09-27 13:44:19 -04:00
4cce94a84e Segregate C20 macros code from other macros for BOOST_PP_IS_EMPTY 2019-09-27 09:44:15 -04:00
2f9be1086a Less wasteful inclusion. 2019-09-26 16:07:03 -04:00
684e9991ec Only include macro if allowable. 2019-09-26 15:05:17 -04:00
a42f374b97 Updated example for using the BOOST_PP_VARIADIC_OPT macro. 2019-09-26 01:19:31 -04:00
0cdd09e6e1 Change to a less wasteful use of BOOST_PP_VARIADIC_OPT in BOOST_PP_IS_EMPTY code. 2019-09-26 00:43:46 -04:00
22deb165b6 Documentation for variadic opt functionality. 2019-09-25 15:43:07 -04:00
e476f10f52 Added OPT macro to determine whether C++20's __VA_OPT__ is supported or not. Updated the undocumented variadic IS_EMPTY to use the functionality of __VA_OPT__ if it exists to provide perfect functionality for testing for emptiness. 2019-09-25 06:29:04 -04:00
c436de6142 Adjusted the configuration so that compiling a cuda source file ( .cu ) using clang does not set BOOST_PP_VARIADICS to 0. An 'explicit' test was also added for this situation. 2019-09-14 10:27:14 -04:00
5756fb08ad Fixed inspect report problems: tabs and lack of copyright notices, and a few other small html file errors. 2019-08-27 01:29:21 -04:00
9b3e6a2cd6 Updated for b2 cmake support. 2018-12-19 22:09:23 -05:00
d135cad759 Merge branch 'develop' 2018-10-25 19:41:15 -04:00
8d26689387 Merge branch 'develop' of https://github.com/boostorg/preprocessor into develop 2018-10-25 16:58:28 -04:00
f78f0a1d25 Removing any forcing of C++ levels. 2018-10-25 16:57:55 -04:00
87fd89a7db Merge pull request #20 from Mike-Devel/min_cmake
[CMake] Generate cmake target that other libraries can use
2018-10-23 09:49:20 -04:00
adf2746626 Add support for vc++ /experimental:preprocessor mode. 2018-10-20 14:02:20 -04:00
fe70754559 Include wchar.h in order to test wide character stringize under C. 2018-10-19 16:57:17 -04:00
45588469f3 Only test wide character stringize in c++. 2018-10-19 16:41:43 -04:00
344ce6abf9 [CMake/CI] Use config_info.cpp for cmake self test 2018-10-17 12:13:45 +02:00
31653b34c9 [CMake/CI] Some cleanup 2018-10-17 12:12:57 +02:00
a4e304ca87 [CMake/CI] Add cmake self test to appveyor 2018-10-17 11:33:21 +02:00
0e335df79e Test for stringize macro and use of variadic in stringize macro. 2018-10-16 16:37:10 -04:00
ee5ed2510d [CMake] Add self-test for cmake file to travis 2018-10-16 19:58:45 +02:00
dd44e1eea5 [CMake] Add minimal cmake file
Generate cmake target that can be used by other libraries
to express their dependency on this library and retrieve
any configuration information such as the include directory.
2018-10-09 14:52:17 +02:00
b5c081bf7a Variadic macro support for the PGI compiler when EDG is being used with it. 2018-09-23 09:12:59 -04:00
347f48afae Back out previous CUDA change to turn on variadic macro support for all situations when compiling a CUDA file. 2018-09-10 17:42:32 -04:00
49a72ac4f2 Corrected sentence by removing extra "the". 2018-08-23 19:20:04 -04:00
56090c56b5 Merge branch 'develop' 2018-02-20 09:13:57 -05:00
00b2f44624 Allow the IBM compiler to default to the level of C++/C compliance to determine default variadic macro support 2018-02-18 09:47:44 -05:00
a329a67b47 NVidia compiler supports variadic macros. 2018-02-14 22:01:04 -05:00
34af3a925c Merge pull request #11 from danieljames/feature/fix-links
Fix some links
2018-01-11 13:02:34 -05:00
ad22f9686e Fix some links 2018-01-11 14:20:16 +00:00
39175c471f Merge branch 'develop' 2017-10-30 11:32:10 -04:00
aa9ee3ae3f Removed --depth 1 2017-10-29 21:31:25 -04:00
50ffeeee8b Merge branch 'develop' 2017-10-27 22:31:37 -04:00
f54e270433 Better appveyor designation for tests. 2017-10-09 11:58:08 -04:00
08ec2abb2e Updated appveyor file for correct toolsets. 2017-10-09 11:39:03 -04:00
c4b1ce10bd Add VS2017 worker image. 2017-10-09 11:23:30 -04:00
1ecc2e2ec9 Added Appveyor file. 2017-10-09 08:09:05 -04:00
b19e4deacb Merge branch 'develop' 2017-04-24 12:13:09 -04:00
dfc1c46ece With _MSC_VER and __clang__ always use strict mode and variadics turned on without any VC++ fixes. 2017-03-26 08:51:41 -07:00
e474eea44f Slight correction to particularize previous change as involving only -fno-ms-compatibility mode. 2017-03-26 01:02:05 -07:00
b03c6cd3c0 In the configuration the combination of clang defined and gcc defined always gets strict mode and variadic macro support, even under Windows where VC++ may also be defined. 2017-03-25 23:22:32 -07:00
a6275942f3 Merge branch 'develop' 2017-02-19 03:21:26 -05:00
d8389ffda6 Exclude tests for gcc when C++0x is not supported. This should fix some test matrices for old versions of gcc. 2017-01-05 09:57:01 -05:00
075a3a02c8 Merge branch 'develop' 2017-01-04 11:29:41 -05:00
dc41624aba Added Travis CI file. Updated config.hpp for Intel 17 on Windows. 2016-11-16 13:01:51 -05:00
4ae346bbc5 Merge pull request #9 from sergiud/intel-17.0-fix
Intel C++ compiler 17.0 fix
2016-11-16 09:40:21 -05:00
d922d757be Fix for VC++ and VC++ emuolations ot the SEQ_TO_LIST macro 2016-11-16 00:15:57 -05:00
eb143c10f8 Added configuration info test. 2016-11-14 00:25:46 -05:00
e1e3a2e21e added Intel C++ compiler 17.0 workaround 2016-11-11 15:30:21 +01:00
c2beb74b90 Updated for VC++ quirks and overload code example. 2016-04-14 08:52:06 -04:00
e70abe7b49 Updated for VC++ quirks and overload code example. 2016-04-11 14:24:38 -04:00
ee73989a21 Further change to ensure that clang targeting VC++ behaves as the VC++ preprocessor 2016-03-30 13:52:02 -04:00
7835ed019c Updated configuration to support clang targeting VC++ 2016-03-30 12:08:46 -04:00
3292532517 Merge branch 'master' into develop 2015-10-16 18:47:02 -04:00
4e29a160b9 Merge branch 'develop' 2015-10-14 22:36:27 -04:00
b1be22cf77 Merge pull request #8 from mgaunard/patch-1
lower version requirement for SunCC and variadics
2015-10-08 11:34:04 -04:00
f59d83b8bf lower version requirement for SunCC and variadics
Macro variadics appear to work fine with SunCC 5.12.
2015-10-08 11:31:27 +01:00
88c4282493 Fixed leaving off first letter of word in doc. 2015-09-21 10:53:10 -07:00
02ab183b96 Added documentation for identity_n macro. 2015-09-13 13:21:57 -04:00
735e301c46 Added BOOST_PP_IDENTITY_N functionality with test. 2015-09-12 19:53:59 -04:00
e983c16e61 Merge branch 'develop' 2015-08-27 21:21:19 -04:00
132eb67cec Remove spaces in the filename for AppendixA. 2015-08-21 16:38:12 -04:00
4c39e92496 Merge branch 'develop' 2015-08-21 09:28:34 -04:00
2689b91d91 Merge pull request #6 from teeks99/unicode_name2
Removed weird unicode character from filename and links
2015-08-17 13:27:17 -04:00
478bb6e10e Removed weird unicode character from filename and links 2015-08-14 17:39:42 -05:00
3c3c7b42d9 Corrected implementation same as 'develop' and updated test sames as 'develop'. 2015-07-17 07:45:08 -04:00
3f97464c27 Added needed include. 2015-07-17 07:16:11 -04:00
d4fbb8fda2 Back out change from 'develop' because of failing MPL test. 2015-07-16 19:52:49 -04:00
38e7f69054 Merge branch 'develop' 2015-07-16 18:16:24 -04:00
3ed3cd689e Added more thorough tests for large seqs 2015-05-30 08:00:33 -04:00
fc6229660e Added not about VC++ compiler limitation 2015-05-29 22:53:01 -04:00
b125850bbb Fixes for BOOST_PP_SEQ_REMOVE when the seq is its maximum size and has its last element removed. Also updated seq tests. 2015-05-29 01:36:06 -04:00
350c0e59b1 Add ned macro 2015-05-27 19:15:45 -04:00
2612bf706c Corrected fix for the for_each problem when dealing with as much as 256 seq elements. 2015-05-27 19:13:22 -04:00
b84235fcb7 Revert "Corrected fix for seq for each processing."
This reverts commit dc61cc1373.
2015-05-27 07:44:30 -04:00
4aa8ae8a01 Disallow variadic macro support for versions below 12.4, since that is the first version with C++11 support. 2015-05-26 17:39:58 -04:00
9044b17f18 For Oracle C++ do not automatically turn off variadic macro support for version 12.3 or higher, since those versions can support C++11. 2015-05-25 23:46:33 -04:00
106f5a43a1 Added local copy of preprocessor introduction from the C++ Template Metaprogramming Book Appendix A 2015-05-20 17:19:31 -04:00
915ab7834c Add local copy of preprocessing tutorail 2015-05-20 16:48:23 -04:00
dc61cc1373 Corrected fix for seq for each processing. 2015-05-19 20:10:39 -04:00
4c2c83f9f2 Backing out for_each and for_each_i changes. 2015-05-19 11:34:02 -04:00
862f64c45c Updated documentation about undefined behavior. 2015-05-18 17:02:48 -04:00
06c18a67f8 Fixed replace when replacing the last element of a 256 element sequence. 2015-05-18 16:36:06 -04:00
eb2a675b8f Added #undef to quell VC++ warnings about macro be redefined. 2015-05-18 10:51:50 -04:00
b12333b419 Fixed problem when repetitions go past 256 and the 257th loop op returns that the repetitions are finished. 2015-05-18 02:14:35 -04:00
1543b5fbf7 Remove need to add extra nil element 2015-05-17 14:54:39 -04:00
86378d648e Removed need to add extra seq element. 2015-05-17 13:30:03 -04:00
633f1e679a Added information about empty data. 2015-05-17 00:46:10 -04:00
4360660e39 Add wstringize.hpp to library header 2015-05-16 23:58:39 -04:00
827ff0905c Cleaner use of preprocessor defines to quell warnings. 2015-05-16 23:44:06 -04:00
9cb039ab8b Merge branch 'develop' 2015-03-28 04:19:20 -04:00
1b3fe1570b Put BOOST_PP_EXPAND in correct place for VC++ 2015-02-02 21:19:50 -05:00
4f0adfb553 Reveert removal of BOOST_PP_EXPAND 2015-02-02 18:04:58 -05:00
01848af60d Merge branch 'vctuple' into develop 2015-01-30 23:16:08 -05:00
dc54fee21c Remove BOOST_PP_EXPAND usage since it is no needed 2015-01-30 23:11:07 -05:00
77a9177c31 Remove extraneous include 2015-01-30 22:15:54 -05:00
f1165249fb Merge branch 'develop' 2015-01-15 15:20:38 -05:00
fd135a078f Added BOOST_PP_LIST_SIZE_D to list of re-entrant macros. 2014-12-09 13:21:49 -05:00
eedd7378f1 Added EQUAL and NOT_EQUAL to re-entrancy list. 2014-12-07 16:04:57 -05:00
e1ade3ea3b Changed explanation of which value should be greater for maximum efficiency. 2014-12-05 00:16:11 -05:00
3760758d4e When the Intellisense compiler is being used wihin the Visual Studio IDE, both __EDG__ and __INTELLISENSE__ are defined along with the usual VC++ predefines. This change adjusts the Boost PP configuration to take into account that situation. 2014-11-09 14:20:03 -05:00
0baf10bfc6 Updated docs to refer to config.hpp rather than variadics.hpp. 2014-11-07 16:35:36 -05:00
e72b298001 Merge branch 'develop' 2014-10-12 18:29:09 -04:00
f77c8f2c85 When using clang variadic macro support is now dependent on the C or C++ version system, and not automatically turned on in all situations. This reduces clang warnings. 2014-08-19 00:32:35 -04:00
9c2ef3ae46 Merge pull request #3 from danieljames/metadata
Create metadata file.
2014-08-18 11:36:36 -04:00
1a40a5ea30 Add metadata file. 2014-08-18 15:09:06 +01:00
15f75eca35 Updated test for "empty" tuple and arrays. 2014-07-21 08:38:07 -04:00
8924ad016f Additional tests for "empty" tuples. 2014-07-20 17:40:34 -04:00
9c478f0c39 Special processing when "empty" single element . 2014-07-20 17:40:02 -04:00
cee3323340 Corrected link. 2014-07-16 19:30:51 -04:00
503175a63e Added copyright and base link back to original macro. 2014-07-03 21:17:20 -04:00
46ff3eb1f4 Correct line endings. 2014-07-03 21:15:56 -04:00
04634b402b Added topics for showing lists of macros which re-enter FOR, REPEAT, and WHILE. 2014-07-03 21:10:26 -04:00
83f05f5325 Add links tio topics for re-entrancies. 2014-07-03 21:02:11 -04:00
00d05d4f04 Added links to topics with macros which use re-entrancy versions. 2014-07-03 20:55:39 -04:00
542bd2653d Use expand to fix VC++ problem. 2014-07-03 16:59:52 -04:00
fd36e236bc get_data not needed. 2014-07-03 16:59:39 -04:00
c4bf80ee1d Cleaner inclusion if is_single_return functionality. 2014-07-03 16:59:30 -04:00
2cea910cd8 Simplify get_data. 2014-07-03 16:59:15 -04:00
4fc958a89d Remove special processing for REM_CTOR wsing VC++. 2014-07-03 16:59:05 -04:00
08c50b219d Added documentation for is_begin_parens and remove_parens. 2014-07-03 16:58:01 -04:00
3a472c2084 Updated docs 2014-07-03 16:56:40 -04:00
4063b1564b Updated doc for empty array and/or list when converted to other data type. 2014-07-03 16:51:28 -04:00
b70598c357 Using BOOST_PP_IDENTITY makes code clearer. 2014-07-03 16:51:17 -04:00
56525c76cc Change back to original implementation. 2014-07-03 16:50:56 -04:00
8ac31eb612 Changed BOOST_PP_EMPTY to only use the variadic version when not VC++. Corrected others to use local version of EMPTY. 2014-07-03 16:50:44 -04:00
f61bb8a80f Changed functionality so empty arrays/lists when converted to a seq or a tuple expand to nothing. 2014-07-03 16:46:20 -04:00
df165d9fc6 Added further tests for empty lists and arrays. 2014-07-03 16:46:07 -04:00
fb732aaab5 Fixes for empty conversions and tests for empty conversions. 2014-07-03 16:45:55 -04:00
9dfce3363c Added remove_parens and tests. 2014-07-03 16:45:22 -04:00
6590e41581 Further tests of changes involving empty data. 2014-07-03 16:45:10 -04:00
ec93b32f82 Corrected calculation _msc_ver number. 2014-07-03 16:44:56 -04:00
6c091d7f99 Removed tests which involve undefined behavior. 2014-07-03 16:44:39 -04:00
b3b9e80f86 Updated tests for strict compilers or VC++ 2014-07-03 16:44:27 -04:00
ea91a3defa Added variadic is_empty tests. 2014-07-03 16:44:13 -04:00
4ed6f6e07a Addition of is_empty tests and changes to rem processing as a workaround to VC++ problem. 2014-07-03 16:44:00 -04:00
2c7cf9410a Added variadic version of BOOST_PP_EMPTY and added new is_empty tests. 2014-07-03 16:43:40 -04:00
975c39b910 Added variadic is_empty and is_begin_parens along with tests. 2014-07-03 16:43:16 -04:00
f80bb83f3b Fixes for empty tuple processing 2014-07-03 16:42:26 -04:00
21ccb35814 Reapply typo fix. 2014-06-17 07:08:04 -04:00
6b0be3fe4f Revert "Merge branch 'master' into develop"
This reverts commit 1422fce0db, reversing
changes made to 9d2d1fffdf.
2014-06-16 23:58:35 -04:00
1422fce0db Merge branch 'master' into develop 2014-06-16 08:43:38 -04:00
9d2d1fffdf Revert use of variadic is_empty. 2014-06-16 07:01:15 -04:00
60691e3a49 Merge branch 'vcoverload' into develop 2014-06-08 10:21:02 -04:00
3f75659921 Added documentation for is_begin_parens and remove_parens. 2014-06-08 02:00:24 -04:00
b43a4708eb Correct line endings. 2014-06-04 19:38:09 -04:00
b923dadf19 Merge pull request #2 from coding-po/Bug_8454
#8454. Fixed minor typo in documentation.
2014-06-04 06:53:42 -04:00
e57370608e Updated doc for empty array and/or list when converted to other data type. 2014-06-04 06:50:33 -04:00
7da3c88d82 #8454. Fixed minor typo in documentation. 2014-05-26 16:55:07 -07:00
70e0f2d6e0 Using BOOST_PP_IDENTITY makes code clearer. 2014-05-26 16:36:30 -04:00
b03d46129c Change back to original implementation. 2014-05-25 07:53:44 -04:00
9d308c1b9d Changed BOOST_PP_EMPTY to only use the variadic version when not VC++. Corrected others to use local version of EMPTY. 2014-05-23 10:23:40 -04:00
1f16a481c7 Changed functionality so empty arrays/lists when converted to a seq or a tuple expand to nothing. 2014-05-05 20:49:20 -04:00
181a88db7e Added further tests for empty lists and arrays. 2014-05-04 23:55:53 -04:00
697ebcd840 Fixes for empty conversions and tests for empty conversions. 2014-05-04 03:07:00 -04:00
70e775452a Added remove_parens and tests. 2014-05-03 02:15:47 -04:00
dec4cfd273 Further tests of changes involving empty data. 2014-05-02 20:17:08 -04:00
7da9dbb7a9 Corrected calculation _msc_ver number. 2014-05-02 02:59:10 -04:00
5c22605c3d Removed tests which involve undefined behavior. 2014-05-01 23:21:05 -04:00
4614c62130 Updated tests for strict compilers or VC++ 2014-05-01 01:20:12 -04:00
fe2a9cbfcc Added variadic is_empty tests. 2014-04-30 16:15:57 -04:00
c66ea5871f Addition of is_empty tests and changes to rem processing as a workaround to VC++ problem. 2014-04-30 16:06:49 -04:00
6fe93a542d Added variadic version of BOOST_PP_EMPTY and added new is_empty tests. 2014-04-28 22:12:08 -04:00
d2bfda8308 Added variadic is_empty and is_begin_parens along with tests. 2014-04-28 19:24:42 -04:00
0a23b4d6a6 Fixes for empty tuple processing 2014-04-27 12:00:13 -04:00
81302d1e69 Merge branch 'develop' 2014-04-01 00:43:06 -04:00
91fb925e1c Correct line ending. 2014-02-27 22:43:23 -05:00
cc9fbc3734 Fix incorrect line ending. 2014-02-27 17:37:30 -05:00
a5ed4fe7d8 Added copyright and base link back to original macro. 2014-02-27 17:25:32 -05:00
042fb29bf1 Added links to topics with macros which use re-entrancy versions. 2014-02-27 17:06:00 -05:00
2b46c0f6bd Added topics for showing lists of macros which re-enter FOR, REPEAT, and WHILE. 2014-02-27 16:49:57 -05:00
7cb46e03ea Change from develop to master. 2014-02-26 09:40:58 -05:00
093216b300 Merge develop to master
Conflicts:
	doc/headers.html
	doc/headers/tuple.html
	doc/ref.html
	doc/topics/variadic_macros.html
2014-02-26 00:53:43 -05:00
b24e7a708d Create first merge point for Git on Master 2014-02-25 23:50:42 -05:00
6978c83372 Explanations about using tuples rather than arrays with variadic macro support. 2013-12-05 17:43:48 -05:00
58cf4ccba9 Updated title explanation about Boost PP usability. 2013-12-05 17:28:42 -05:00
d11b03ad1e Updated tests to cover more areas of the implementation. 2013-12-05 14:43:02 -05:00
b3cdac0ea2 Updated tests.
[SVN r86789]
2013-11-23 07:45:00 +00:00
b03b732a19 Updated documentation for tuples.
[SVN r86788]
2013-11-23 03:59:40 +00:00
e9bdfe5276 Corrected description.
[SVN r86783]
2013-11-22 04:00:54 +00:00
b8eb1e0149 Updated tuple docujmentation for new functionality.
[SVN r86782]
2013-11-22 03:38:17 +00:00
428b3c5103 The clang compiler now supports variadic macros by default.
[SVN r86780]
2013-11-21 18:57:41 +00:00
25dbb38e1e Updated tuple tests.
[SVN r86766]
2013-11-19 14:53:24 +00:00
8647354545 Updated tuple rem documentation.
[SVN r86761]
2013-11-19 04:31:38 +00:00
9d3203eb71 Fixes for VC++ and variadic size usage.
[SVN r86760]
2013-11-19 02:47:23 +00:00
e607287986 Updated array tests.
[SVN r86743]
2013-11-17 22:23:51 +00:00
b3a1643428 Fix to BOOST_PP_TUPLE_REM for VC++8.0 and note in documentation about it.
[SVN r86742]
2013-11-17 22:05:23 +00:00
8179a114c3 Added new tuple headers and updated tests to use a common test source file for each test.
[SVN r86715]
2013-11-15 23:54:12 +00:00
390d72525e Update to restore BOOST_PP_TUPLE_REM_0()
[SVN r86141]
2013-10-02 23:21:31 +00:00
5e0422ff97 Reinstate fix for clang so that it is recognized as strict compliance.
[SVN r86044]
2013-09-30 02:04:47 +00:00
06b1bf9b21 Revert previous change for clang.
[SVN r86011]
2013-09-29 19:21:46 +00:00
1cd181a946 Changed for clang on Windows which defines _MSC_VER.
[SVN r86004]
2013-09-29 15:16:25 +00:00
6f56be00ee Update to restore BOOST_PP_TUPLE_REM_0()
[SVN r85172]
2013-07-30 00:36:47 +00:00
d51297c62b Removed redundant explanation.
[SVN r83898]
2013-04-14 14:48:50 +00:00
e630b6e23f Updated documentation linking the (v) notation to a named anchor explaining it.
[SVN r83891]
2013-04-14 01:46:09 +00:00
b07cc69819 Updated documentation linking the (v) notation to a named anchor explaining it.
[SVN r83890]
2013-04-14 00:50:30 +00:00
b60a47252d added VARIADIC_SEQ_TO_SEQ
[SVN r80704]
2012-09-26 03:50:27 +00:00
c48da5375b pp-lib variadic changes merged to release branch
[SVN r75915]
2011-12-12 12:52:44 +00:00
7346503b96 Update link to the C++ Template Metaprogramming book Appendix A online.
[SVN r75126]
2011-10-27 02:10:02 +00:00
46caf30af4 Update link to the C++ Template Metaprogramming book Appendix A online.
[SVN r75125]
2011-10-27 02:03:36 +00:00
3443ca0a51 Delay of BOOST_PP_VARIADIC_ELEM fixes problem when variadic data must be generated.
[SVN r73776]
2011-08-15 15:58:25 +00:00
1149d38ef4 limited variadic support
[SVN r72763]
2011-06-26 13:07:20 +00:00
c81e77bb16 Merge [43112], [62165], [65119], and [65120] from the trunk.
[SVN r71037]
2011-04-06 17:22:43 +00:00
0c87b91f95 gcc fix
[SVN r70733]
2011-03-30 01:14:17 +00:00
49142ec930 commit test
[SVN r69130]
2011-02-21 22:51:57 +00:00
c776ac0002 Avoid evaluating BOOST_PP_SEQ_HEAD when it isn't needed. Fixes #4465.
[SVN r65120]
2010-08-30 02:26:02 +00:00
568f641d8e Remove unused #include. Refs #4465.
[SVN r65119]
2010-08-30 02:24:41 +00:00
9548743659 Fix some minor documentation errors. Fixes #4224
[SVN r62165]
2010-05-23 14:44:57 +00:00
0882fe63f9 rm cmake from trunk. I'm not entirely sure this is necessary to satisfy the inspect script, but I'm not taking any chances, and it is easy to put back
[SVN r56942]
2009-10-17 02:07:38 +00:00
e582010b1f Copyrights on CMakeLists.txt to keep them from clogging up the inspect
reports.  This is essentially the same commit as r55095 on the release
branch.



[SVN r55159]
2009-07-26 00:49:56 +00:00
328bd6f995 Updating dependency information for modularized libraries.
[SVN r49628]
2008-11-07 17:05:27 +00:00
8ed342548e Updating CMake files to latest trunk. Added dependency information for regression tests and a few new macros for internal use.
[SVN r49627]
2008-11-07 17:02:56 +00:00
c213502e2c Continuing merge of CMake build system files into trunk with the encouragement of Doug Gregor
[SVN r49510]
2008-11-01 13:15:41 +00:00
485db8aef5 Move preprocessor tests into canonical test subdir structure.
[SVN r44385]
2008-04-13 23:21:57 +00:00
aba62cac02 Fix typo (bug #1434)
[SVN r43112]
2008-02-05 16:07:19 +00:00
fee02ed013 EDG MS emulation
[SVN r37155]
2007-03-07 10:27:38 +00:00
d88bf38702 removed single-line comment
[SVN r36257]
2006-12-04 00:43:44 +00:00
e8937f9f13 fixed flags argument bug
[SVN r36177]
2006-11-25 23:13:08 +00:00
94ffea3b73 Fix freshly broken links, again.
[SVN r34764]
2006-07-28 16:06:08 +00:00
eb1edeed0b Fix freshly broken links.
[SVN r34734]
2006-07-26 01:19:35 +00:00
36885cddae After asking Paul... add his copyright to the docs.
[SVN r34691]
2006-07-24 04:08:25 +00:00
b14b395cec Fix various inspection errors: add missing copyright and license info.
[SVN r34683]
2006-07-23 20:45:18 +00:00
0e2bbd51ce added x-refs
[SVN r33472]
2006-03-24 21:34:52 +00:00
479 changed files with 124432 additions and 3358 deletions

52
.drone.star Normal file
View File

@ -0,0 +1,52 @@
# Use, modification, and distribution are
# subject to the Boost Software License, Version 1.0. (See accompanying
# file LICENSE.txt)
#
# Copyright Rene Rivera 2020.
# For Drone CI we use the Starlark scripting language to reduce duplication.
# As the yaml syntax for Drone CI is rather limited.
#
#
globalenv={}
linuxglobalimage="cppalliance/droneubuntu1604:1"
windowsglobalimage="cppalliance/dronevs2019"
def main(ctx):
return [
linux_cxx("TOOLSET=gcc COMPILER=g++ CXXSTD=03,11 Job 0", "g++", packages="", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': 'b6589fc6ab'}, globalenv=globalenv),
linux_cxx("TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98 Job 1", "g++", packages="g++-4.4", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.4', 'CXXSTD': '98', 'DRONE_JOB_UUID': '356a192b79'}, globalenv=globalenv),
linux_cxx("TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x Job 2", "g++", packages="g++-4.6", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.6', 'CXXSTD': '03,0x', 'DRONE_JOB_UUID': 'da4b9237ba'}, globalenv=globalenv),
linux_cxx("TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11 Job 3", "g++-4.7", packages="g++-4.7", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.7', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': '77de68daec'}, globalenv=globalenv),
linux_cxx("TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11 Job 4", "g++-4.8", packages="g++-4.8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.8', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': '1b64538924'}, globalenv=globalenv),
linux_cxx("TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11 Job 5", "g++-4.9", packages="g++-4.9", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.9', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': 'ac3478d69a'}, globalenv=globalenv),
linux_cxx("TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z Job 6", "g++-5", packages="g++-5", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-5', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'c1dfd96eea'}, globalenv=globalenv),
linux_cxx("TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z Job 7", "g++-6", packages="g++-6", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '902ba3cda1'}, globalenv=globalenv),
linux_cxx("TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17 Job 8", "g++-7", packages="g++-7", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '03,11,14,17', 'DRONE_JOB_UUID': 'fe5dbbcea5'}, globalenv=globalenv),
linux_cxx("TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17 Job 9", "g++-8", packages="g++-8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': '03,11,14,17', 'DRONE_JOB_UUID': '0ade7c2cf9'}, globalenv=globalenv),
linux_cxx("TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17 Job 10", "g++-9", packages="g++-9", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '03,11,14,17', 'DRONE_JOB_UUID': 'b1d5781111'}, globalenv=globalenv),
linux_cxx("TOOLSET=gcc COMPILER=g++-10 CXXSTD=03,11,14,1 Job 11", "g++-10", packages="g++-10", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_UUID': '17ba079149'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=03,11 Job 12", "clang++", packages="", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': '7b52009b64'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=/usr/bin/clang++ CXXST Job 13", "/usr/bin/clang++", packages="clang-3.3", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': '/usr/bin/clang++', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': 'bd307a3ec3'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=/usr/bin/clang++ CXXST Job 14", "/usr/bin/clang++", packages="clang-3.4", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': '/usr/bin/clang++', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': 'fa35e19212'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03, Job 15", "clang++", packages="clang-3.5", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.5', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'f1abd67035'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03, Job 16", "clang++", packages="clang-3.6", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.6', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '1574bddb75'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03, Job 17", "clang++", packages="clang-3.7", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.7', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '0716d9708d'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03, Job 18", "clang++-3.8", packages="clang-3.8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.8', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '9e6a55b6b4'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03, Job 19", "clang++-3.9", packages="clang-3.9", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.9', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'b3f0c7f6bb'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03, Job 20", "clang++-4.0", packages="clang-4.0", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-4.0', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '91032ad7bb'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03, Job 21", "clang++-5.0", packages="clang-5.0", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-5.0', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '472b07b9fc'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03, Job 22", "clang++-6.0", packages="clang-6.0", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-6.0', 'CXXSTD': '03,11,14,17', 'DRONE_JOB_UUID': '12c6fc06c9'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11 Job 23", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '03,11,14,17', 'DRONE_JOB_UUID': 'd435a6cdd7'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11 Job 24", "clang++-8", packages="clang-8", llvm_os="xenial", llvm_ver="8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '03,11,14,17', 'DRONE_JOB_UUID': '4d134bc072'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=clang++-9 CXXSTD=03,11 Job 25", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_UUID': 'f6e1126ced'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,1 Job 26", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_UUID': '887309d048'}, globalenv=globalenv),
linux_cxx("TOOLSET=clang COMPILER=clang++-libc++ CXXSTD= Job 27", "clang++-libc++", packages="libc++-dev", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-libc++', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'bc33ea4e26'}, globalenv=globalenv),
osx_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,1 Job 28", "clang++", packages="", buildtype="boost", buildscript="drone", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '0a57cb53ba'}, globalenv=globalenv),
linux_cxx("CMAKE_TEST=1 Job 29", "g++", packages="", buildtype="cmake-test-script", buildscript="drone", image=linuxglobalimage, environment={'CMAKE_TEST': '1', 'DRONE_JOB_UUID': '7719a1c782'}, globalenv=globalenv),
linux_cxx("CMAKE_SUBDIR_TEST=1 Job 30", "g++", packages="", buildtype="cmake-subdir-script", buildscript="drone", image=linuxglobalimage, environment={'CMAKE_SUBDIR_TEST': '1', 'DRONE_JOB_UUID': '22d200f867'}, globalenv=globalenv),
linux_cxx("CMAKE_INSTALL_TEST=1 Job 31", "g++", packages="", buildtype="cmake-install-script", buildscript="drone", image=linuxglobalimage, environment={'CMAKE_INSTALL_TEST': '1', 'DRONE_JOB_UUID': '632667547e'}, globalenv=globalenv),
]
# from https://github.com/boostorg/boost-ci
load("@boost_ci//ci/drone/:functions.star", "linux_cxx","windows_cxx","osx_cxx","freebsd_cxx")

88
.drone/drone.sh Executable file
View File

@ -0,0 +1,88 @@
#!/bin/bash
set -ex
export TRAVIS_BUILD_DIR=$(pwd)
export DRONE_BUILD_DIR=$(pwd)
export TRAVIS_BRANCH=$DRONE_BRANCH
export VCS_COMMIT_ID=$DRONE_COMMIT
export GIT_COMMIT=$DRONE_COMMIT
export REPO_NAME=$DRONE_REPO
export PATH=~/.local/bin:/usr/local/bin:$PATH
if [ "$DRONE_JOB_BUILDTYPE" == "boost" ]; then
echo '==================================> INSTALL'
BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
cd ..
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
cd boost-root
git submodule update --init tools/boostdep
cp -r $TRAVIS_BUILD_DIR/* libs/preprocessor
python tools/boostdep/depinst/depinst.py preprocessor
./bootstrap.sh
./b2 headers
echo '==================================> SCRIPT'
echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
./b2 libs/preprocessor/test -j 3 toolset=$TOOLSET cxxstd=$CXXSTD $ADDRMD
elif [ "$DRONE_JOB_BUILDTYPE" == "cmake-install-script" ]; then
echo '==================================> INSTALL'
BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
cd ..
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
cd boost-root
git submodule update --init tools/boostdep
cp -r $TRAVIS_BUILD_DIR/* libs/preprocessor
python tools/boostdep/depinst/depinst.py preprocessor
./bootstrap.sh
./b2 headers
echo '==================================> SCRIPT'
mkdir __build__ && cd __build__
cmake -DBOOST_ENABLE_CMAKE=1 -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES=preprocessor -DCMAKE_INSTALL_PREFIX=~/.local ..
cmake --build . --target install
cd ../libs/preprocessor/test/cmake_install_test && mkdir __build__ && cd __build__
cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
cmake --build .
cmake --build . --target check
elif [ "$DRONE_JOB_BUILDTYPE" == "cmake-subdir-script" ]; then
echo '==================================> INSTALL'
true
echo '==================================> SCRIPT'
cd test/cmake_subdir_test && mkdir __build__ && cd __build__
cmake ..
cmake --build .
cmake --build . --target check
elif [ "$DRONE_JOB_BUILDTYPE" == "cmake-test-script" ]; then
echo '==================================> INSTALL'
BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
cd ..
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
cd boost-root
git submodule update --init tools/boostdep
cp -r $TRAVIS_BUILD_DIR/* libs/preprocessor
python tools/boostdep/depinst/depinst.py preprocessor
./bootstrap.sh
./b2 headers
echo '==================================> SCRIPT'
mkdir __build__ && cd __build__
cmake -DBOOST_ENABLE_CMAKE=1 -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES=preprocessor ..
ctest --output-on-failure -R boost_preprocessor
fi

369
.github/workflows/ci.yml vendored Normal file
View File

@ -0,0 +1,369 @@
name: CI
on:
pull_request:
push:
branches:
- master
- develop
- feature/**
env:
UBSAN_OPTIONS: print_stacktrace=1
jobs:
posix:
strategy:
fail-fast: false
matrix:
include:
- toolset: gcc-4.8
cxxstd: "03,11"
os: ubuntu-18.04
install: g++-4.8
- toolset: gcc-5
cxxstd: "03,11,14,1z"
os: ubuntu-18.04
install: g++-5
- toolset: gcc-6
cxxstd: "03,11,14,1z"
os: ubuntu-18.04
install: g++-6
- toolset: gcc-7
cxxstd: "03,11,14,17"
os: ubuntu-18.04
- toolset: gcc-8
cxxstd: "03,11,14,17,2a"
os: ubuntu-20.04
install: g++-8
- toolset: gcc-9
cxxstd: "03,11,14,17,2a"
os: ubuntu-20.04
- toolset: gcc-10
cxxstd: "03,11,14,17,2a"
os: ubuntu-20.04
install: g++-10
- toolset: gcc-11
cxxstd: "03,11,14,17,2a"
os: ubuntu-20.04
install: g++-11
- toolset: gcc-12
cxxstd: "03,11,14,17,20,2b"
os: ubuntu-22.04
install: g++-12
- toolset: clang
compiler: clang++-3.9
cxxstd: "03,11,14"
os: ubuntu-18.04
install: clang-3.9
- toolset: clang
compiler: clang++-4.0
cxxstd: "03,11,14"
os: ubuntu-18.04
install: clang-4.0
- toolset: clang
compiler: clang++-5.0
cxxstd: "03,11,14,1z"
os: ubuntu-18.04
install: clang-5.0
- toolset: clang
compiler: clang++-6.0
cxxstd: "03,11,14,17"
os: ubuntu-18.04
install: clang-6.0
- toolset: clang
compiler: clang++-7
cxxstd: "03,11,14,17"
os: ubuntu-18.04
install: clang-7
- toolset: clang
compiler: clang++-8
cxxstd: "03,11,14,17"
os: ubuntu-20.04
install: clang-8
- toolset: clang
compiler: clang++-9
cxxstd: "03,11,14,17,2a"
os: ubuntu-20.04
install: clang-9
- toolset: clang
compiler: clang++-10
cxxstd: "03,11,14,17,2a"
os: ubuntu-20.04
install: clang-10
- toolset: clang
compiler: clang++-11
cxxstd: "03,11,14,17,2a"
os: ubuntu-20.04
install: clang-11
- toolset: clang
compiler: clang++-12
cxxstd: "03,11,14,17,2a"
os: ubuntu-20.04
install: clang-12
- toolset: clang
compiler: clang++-13
cxxstd: "03,11,14,17,20,2b"
os: ubuntu-22.04
install: clang-13
- toolset: clang
compiler: clang++-14
cxxstd: "03,11,14,17,20,2b"
os: ubuntu-22.04
install: clang-14
- toolset: clang
cxxstd: "03,11,14,17,2a"
os: macos-11
runs-on: ${{matrix.os}}
steps:
- uses: actions/checkout@v2
- name: Install packages
if: matrix.install
run: sudo apt install ${{matrix.install}}
- name: Setup Boost
run: |
echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
LIBRARY=${GITHUB_REPOSITORY#*/}
echo LIBRARY: $LIBRARY
echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
echo GITHUB_BASE_REF: $GITHUB_BASE_REF
echo GITHUB_REF: $GITHUB_REF
REF=${GITHUB_BASE_REF:-$GITHUB_REF}
REF=${REF#refs/heads/}
echo REF: $REF
BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
echo BOOST_BRANCH: $BOOST_BRANCH
cd ..
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
cd boost-root
cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
git submodule update --init tools/boostdep
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
./bootstrap.sh
./b2 -d0 headers
- name: Create user-config.jam
if: matrix.compiler
run: |
echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
- name: Run tests
run: |
cd ../boost-root
./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release
windows:
strategy:
fail-fast: false
matrix:
include:
- toolset: msvc-14.0
cxxstd: "14,latest"
addrmd: 32,64
os: windows-2019
- toolset: msvc-14.2
cxxstd: "14,17,20,latest"
addrmd: 32,64
os: windows-2019
- toolset: msvc-14.3
cxxstd: "14,17,20,latest"
addrmd: 32,64
os: windows-2022
- toolset: clang-win
cxxstd: "14,17,latest"
addrmd: 32,64
os: windows-2022
- toolset: gcc
cxxstd: "03,11,14,17,2a"
addrmd: 64
os: windows-2019
runs-on: ${{matrix.os}}
steps:
- uses: actions/checkout@v2
- name: Setup Boost
shell: cmd
run: |
echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
echo LIBRARY: %LIBRARY%
echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
echo GITHUB_REF: %GITHUB_REF%
if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
set BOOST_BRANCH=develop
for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
echo BOOST_BRANCH: %BOOST_BRANCH%
cd ..
git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
cd boost-root
xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
git submodule update --init tools/boostdep
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
cmd /c bootstrap
b2 -d0 headers
- name: Run tests
shell: cmd
run: |
cd ../boost-root
b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release embed-manifest-via=linker
posix-cmake-subdir:
strategy:
fail-fast: false
matrix:
include:
- os: ubuntu-latest
- os: macos-latest
runs-on: ${{matrix.os}}
steps:
- uses: actions/checkout@v2
- name: Install packages
if: matrix.install
run: sudo apt install ${{matrix.install}}
- name: Setup Boost
run: |
echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
LIBRARY=${GITHUB_REPOSITORY#*/}
echo LIBRARY: $LIBRARY
echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
echo GITHUB_BASE_REF: $GITHUB_BASE_REF
echo GITHUB_REF: $GITHUB_REF
REF=${GITHUB_BASE_REF:-$GITHUB_REF}
REF=${REF#refs/heads/}
echo REF: $REF
BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
echo BOOST_BRANCH: $BOOST_BRANCH
cd ..
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
cd boost-root
cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
git submodule update --init tools/boostdep
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
- name: Use library with add_subdirectory
run: |
cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
mkdir __build__ && cd __build__
cmake ..
cmake --build .
ctest --output-on-failure --no-tests=error
posix-cmake-install:
strategy:
fail-fast: false
matrix:
include:
- os: ubuntu-latest
- os: macos-latest
runs-on: ${{matrix.os}}
steps:
- uses: actions/checkout@v2
- name: Install packages
if: matrix.install
run: sudo apt install ${{matrix.install}}
- name: Setup Boost
run: |
echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
LIBRARY=${GITHUB_REPOSITORY#*/}
echo LIBRARY: $LIBRARY
echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
echo GITHUB_BASE_REF: $GITHUB_BASE_REF
echo GITHUB_REF: $GITHUB_REF
REF=${GITHUB_BASE_REF:-$GITHUB_REF}
REF=${REF#refs/heads/}
echo REF: $REF
BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
echo BOOST_BRANCH: $BOOST_BRANCH
cd ..
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
cd boost-root
cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
git submodule update --init tools/boostdep
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
- name: Configure
run: |
cd ../boost-root
mkdir __build__ && cd __build__
cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
- name: Install
run: |
cd ../boost-root/__build__
cmake --build . --target install
- name: Use the installed library
run: |
cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
cmake --build .
ctest --output-on-failure --no-tests=error
posix-cmake-test:
strategy:
fail-fast: false
matrix:
include:
- os: ubuntu-latest
- os: macos-latest
runs-on: ${{matrix.os}}
steps:
- uses: actions/checkout@v2
- name: Install packages
if: matrix.install
run: sudo apt install ${{matrix.install}}
- name: Setup Boost
run: |
echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
LIBRARY=${GITHUB_REPOSITORY#*/}
echo LIBRARY: $LIBRARY
echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
echo GITHUB_BASE_REF: $GITHUB_BASE_REF
echo GITHUB_REF: $GITHUB_REF
REF=${GITHUB_BASE_REF:-$GITHUB_REF}
REF=${REF#refs/heads/}
echo REF: $REF
BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
echo BOOST_BRANCH: $BOOST_BRANCH
cd ..
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
cd boost-root
cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
git submodule update --init tools/boostdep
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
- name: Configure
run: |
cd ../boost-root
mkdir __build__ && cd __build__
cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
- name: Build tests
run: |
cd ../boost-root/__build__
cmake --build . --target tests
- name: Run tests
run: |
cd ../boost-root/__build__
ctest --output-on-failure --no-tests=error

348
.travis.yml Normal file
View File

@ -0,0 +1,348 @@
# Copyright 2016-2019 Peter Dimov
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
language: cpp
dist: xenial
branches:
only:
- master
- develop
- /feature\/.*/
env:
matrix:
- BOGUS_JOB=true
matrix:
exclude:
- env: BOGUS_JOB=true
include:
- os: linux
compiler: g++
env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
- os: linux
compiler: g++-4.4
env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98
addons:
apt:
packages:
- g++-4.4
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: g++-4.6
env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
addons:
apt:
packages:
- g++-4.6
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: g++-4.7
env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
addons:
apt:
packages:
- g++-4.7
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: g++-4.8
env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
addons:
apt:
packages:
- g++-4.8
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: g++-4.9
env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
addons:
apt:
packages:
- g++-4.9
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: g++-5
env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- g++-5
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: g++-6
env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- g++-6
sources:
- ubuntu-toolchain-r-test
- os: linux
dist: trusty
compiler: g++-7
env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
addons:
apt:
packages:
- g++-7
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: g++-8
env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
addons:
apt:
packages:
- g++-8
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: g++-9
env: TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17
addons:
apt:
packages:
- g++-9
sources:
- ubuntu-toolchain-r-test
- os: linux
dist: bionic
compiler: g++-10
env: TOOLSET=gcc COMPILER=g++-10 CXXSTD=03,11,14,17,2a
addons:
apt:
packages:
- g++-10
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: clang++
env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
- os: linux
dist: trusty
compiler: /usr/bin/clang++
env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
addons:
apt:
packages:
- clang-3.3
- os: linux
dist: trusty
compiler: /usr/bin/clang++
env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
addons:
apt:
packages:
- clang-3.4
- os: linux
compiler: clang++-3.5
env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- clang-3.5
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: clang++-3.6
env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- clang-3.6
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: clang++-3.7
env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- clang-3.7
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: clang++-3.8
env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- clang-3.8
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: clang++-3.9
env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- clang-3.9
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: clang++-4.0
env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- clang-4.0
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: clang++-5.0
env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- clang-5.0
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: clang++-6.0
env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
addons:
apt:
packages:
- clang-6.0
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: clang++-7
env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17
addons:
apt:
packages:
- clang-7
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-xenial-7
- os: linux
compiler: clang++-8
env: TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17
addons:
apt:
packages:
- clang-8
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-xenial-8
- os: linux
compiler: clang++-9
env: TOOLSET=clang COMPILER=clang++-9 CXXSTD=03,11,14,17,2a
addons:
apt:
packages:
- clang-9
sources:
- ubuntu-toolchain-r-test
- sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main'
key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
- os: linux
compiler: clang++-10
env: TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,2a
addons:
apt:
packages:
- clang-10
sources:
- ubuntu-toolchain-r-test
- sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main'
key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
- os: linux
dist: trusty
compiler: clang++-libc++
env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
addons:
apt:
packages:
- libc++-dev
- os: osx
compiler: clang++
env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
- os: linux
env: CMAKE_TEST=1
script:
- mkdir __build__ && cd __build__
- cmake -DBUILD_TESTING=ON -DBOOST_INCLUDE_LIBRARIES=preprocessor ..
- cmake --build . --target tests
- ctest --output-on-failure
- os: linux
env: CMAKE_SUBDIR_TEST=1
install: true
script:
- cd test/cmake_subdir_test && mkdir __build__ && cd __build__
- cmake ..
- cmake --build .
- cmake --build . --target check
- os: linux
env: CMAKE_INSTALL_TEST=1
script:
- pip install --user cmake
- mkdir __build__ && cd __build__
- cmake -DBOOST_INCLUDE_LIBRARIES=preprocessor -DCMAKE_INSTALL_PREFIX=~/.local ..
- cmake --build . --target install
- cd ../libs/preprocessor/test/cmake_install_test && mkdir __build__ && cd __build__
- cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
- cmake --build .
- cmake --build . --target check
install:
- BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
- cd ..
- git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
- cd boost-root
- git submodule update --init tools/boostdep
- cp -r $TRAVIS_BUILD_DIR/* libs/preprocessor
- python tools/boostdep/depinst/depinst.py preprocessor
- ./bootstrap.sh
- ./b2 headers
script:
- |-
echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
- ./b2 libs/preprocessor/test -j 3 toolset=$TOOLSET cxxstd=$CXXSTD $ADDRMD
notifications:
email:
on_success: always

18
CMakeLists.txt Normal file
View File

@ -0,0 +1,18 @@
# Copyright 2019 Peter Dimov
# 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
cmake_minimum_required(VERSION 3.5...3.16)
project(boost_preprocessor VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
add_library(boost_preprocessor INTERFACE)
add_library(Boost::preprocessor ALIAS boost_preprocessor)
target_include_directories(boost_preprocessor INTERFACE include)
if(BUILD_TESTING)
add_subdirectory(test)
endif()

123
appveyor.yml Normal file
View File

@ -0,0 +1,123 @@
# Copyright 2017 Edward Diener
# Copyright 2018 Mike Dev
# Copyright 2019 Peter Dimov
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
version: 1.0.{build}-{branch}
shallow_clone: true
configuration:
- boost_build_test
- cmake_test
- cmake_subdir_test
- cmake_install_test
branches:
only:
- master
- develop
- /feature\/.*/
environment:
matrix:
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
TOOLSET: msvc-10.0
ADDRMD: 32
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
TOOLSET: msvc-11.0
ADDRMD: 32
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
TOOLSET: msvc-12.0
ADDRMD: 32,64
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
TOOLSET: msvc-14.0
ADDRMD: 32,64
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
TOOLSET: msvc-14.1
ADDRMD: 32,64
CXXSTD: 14,17,latest
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
TOOLSET: msvc-14.2
ADDRMD: 32,64
CXXSTD: 14,17,latest
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
TOOLSET: msvc-14.2
ADDRMD: 32,64
CXXSTD: 14,17,latest
PREPROCESSOR: /Zc:preprocessor
matrix:
exclude:
- configuration: cmake_test
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
- configuration: cmake_test
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
- configuration: cmake_test
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
build: off
install:
- set BOOST_BRANCH=develop
- if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
- cd ..
- git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
- cd boost-root
- git submodule update --init tools/build
- git submodule update --init libs/config
- git submodule update --init tools/boostdep
- git submodule update --init tools/boost_install
- git submodule update --init libs/headers
- xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\preprocessor\
- python tools/boostdep/depinst/depinst.py preprocessor
for:
-
matrix:
only:
- configuration: boost_build_test
test_script:
- bootstrap
- b2 -d0 headers
- if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
- if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
- if not "%PREPROCESSOR%" == "" set PREPROCESSOR=cflags="%PREPROCESSOR%"
- b2 libs/preprocessor/test -j3 toolset=%TOOLSET% %CXXSTD% %ADDRMD% %PREPROCESSOR% variant=debug,release
-
matrix:
only:
- configuration: cmake_test
test_script:
- mkdir __build__ && cd __build__
- cmake -DBOOST_ENABLE_CMAKE=1 -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES=preprocessor ..
- ctest --output-on-failure -R boost_preprocessor -C Debug
-
matrix:
only:
- configuration: cmake_subdir_test
test_script:
- cd libs/preprocessor/test/cmake_subdir_test && mkdir __build__ && cd __build__
- cmake ..
- cmake --build .
- cmake --build . --target check
-
matrix:
only:
- configuration: cmake_install_test
test_script:
- mkdir __build__ && cd __build__
- cmake -DBOOST_ENABLE_CMAKE=1 -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES=preprocessor -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
- cmake --build . --target install
- cd ../libs/preprocessor/test/cmake_install_test && mkdir __build__ && cd __build__
- cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
- cmake --build .
- cmake --build . --target check

File diff suppressed because it is too large Load Diff

View File

@ -1,29 +1,37 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>contents.html</title>
<link rel="stylesheet" type="text/css" href="styles.css">
<style>
<head>
<meta content="text/html; charset=windows-1252"
http-equiv="content-type">
<title>contents.html</title>
<link rel="stylesheet" type="text/css" href="styles.css">
<style>
a, a:link, a:visited { color: black; font-weight: bold; }
</style>
</head>
<body>
<h4><a href="http://boost-consulting.com/tmpbook/preprocessor.html" target="_top">Introduction</a></h4>
<h4><a href="topics.html">Topics</h4>
<h4><a href="terms.html">Terminology</h4>
<h4><a href="data.html">Data Types</h4>
<h4><a href="ref.html">Reference</h4>
<h4><a href="headers.html">Headers</h4>
<h4><a href="examples.html">Examples</h4>
<h4><a href="miscellanea.html">Miscellanea</h4>
<!--
<EFBFBD> Copyright Housemarque Oy 2002
<EFBFBD> Copyright Paul Mensonides 2002
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)
-->
</body>
</html>
</head>
<body>
<h4><a href="index.html" target="_top">Introduction</a></h4>
<h4><a
href="AppendixA-AnIntroductiontoPreprocessorMetaprogramming.html"
target="_top">Basic Intro</a></h4>
<a href="topics.html"> </a>
<h4><a href="topics.html">Topics</a></h4>
<a href="topics.html"> </a>
<h4><a href="terms.html">Terminology</a></h4>
<a href="terms.html"> </a>
<h4><a href="data.html">Data Types</a></h4>
<a href="data.html"> </a>
<h4><a href="ref.html">Reference</a></h4>
<a href="ref.html"> </a>
<h4><a href="headers.html">Headers</a></h4>
<a href="headers.html"> </a>
<h4><a href="examples.html">Examples</a></h4>
<a href="examples.html"> </a>
<h4><a href="miscellanea.html">Miscellanea</a></h4>
<a href="miscellanea.html">
<!--
<EFBFBD> Copyright Housemarque Oy 2002<30> Copyright Paul Mensonides 2002
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)--> </a>
</body>
</html>

View File

@ -1,53 +1,53 @@
<html>
<head>
<title>arrays.html</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<h4>Arrays</h4>
<div>
An <i>array</i> is a data structure consisting of a two-element <i>tuple</i>.&nbsp;
The first element is the number of elements in the <i>array</i>.&nbsp;
The second element is another <i>tuple</i> of the elements in the <i>array</i>.&nbsp;
For example,
</div>
<div class="code">
(<i>3</i>, (<i>a</i>, <i>b</i>, <i>c</i>))
</div>
<div>
...is an <i>array</i> of <i>3</i> elements--<i>a</i>, <i>b</i>, and <i>c</i>.
</div>
<div>
The primary strength of <i>arrays</i> is that they store their own size.&nbsp;
Because of this, access to elements does not require the size.&nbsp;
It only requires that an element exists at a certain index.
</div>
<div>
This allows macro parameters to be variable in size and allows data states to change
size without the user explicitly keeping track of the size independently.
</div>
<div>
Elements of an <i>array</i> can be extracted with <b>BOOST_PP_ARRAY_ELEM</b>,
an <i>array's</i> size can be extracted with <b>BOOST_PP_ARRAY_SIZE</b>, and
an <i>array</i> can be converted to the more primitive <i>tuple</i> data structure
with <b>BOOST_PP_ARRAY_DATA</b>.
</div>
<h4>Primitives</h4>
<ul>
<li><a href="../ref/array_data.html">BOOST_PP_ARRAY_DATA</a></li>
<li><a href="../ref/array_elem.html">BOOST_PP_ARRAY_ELEM</a></li>
<li><a href="../ref/array_size.html">BOOST_PP_ARRAY_SIZE</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>arrays.html</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<h4>Arrays</h4>
<div> An <i>array</i> is a data structure consisting of a two-element <i>tuple</i>.&nbsp;
The first element is the number of elements in the <i>array</i>.&nbsp;
The second element is another <i>tuple</i> of the elements in the <i>array</i>.&nbsp;
For example, </div>
<div class="code"> (<i>3</i>, (<i>a</i>, <i>b</i>, <i>c</i>)) </div>
<div> ...is an <i>array</i> of <i>3</i> elements--<i>a</i>, <i>b</i>, and
<i>c</i>. </div>
<div> The primary strength of <i>arrays</i> is that they store their own
size.&nbsp; Because of this, access to elements does not require the
size.&nbsp; It only requires that an element exists at a certain index. </div>
<div> This allows macro parameters to be variable in size and allows data
states to change size without the user explicitly keeping track of the
size independently.<br>
<br>
An <i>array </i>can be empty and have no elements. An empty array has a
0 size. The notation for an empty array is '(0,())'.<br>
<br>
<span style="font-style: italic;"> </span></div>
<div>A <i>tuple </i>has all of the
functionality as an <i>array</i>, knows its own size, and is easier
syntactically to use. The only advantage an <i>array </i>has over a <i>tuple
</i>is that an <i>array </i>can be empty while a <i>tuple </i>always
has at least one element and therefore can never have a size of 0.<br>
<br>
Elements of an <i>array</i> can be extracted with <b>BOOST_PP_ARRAY_ELEM</b>,
an <i>array's</i> size can be extracted with <b>BOOST_PP_ARRAY_SIZE</b>,
and an <i>array</i> can be converted to the more primitive <i>tuple</i>
data structure with <b>BOOST_PP_ARRAY_DATA</b>. </div>
<h4>Primitives</h4>
<ul>
<li><a href="../ref/array_data.html">BOOST_PP_ARRAY_DATA</a></li>
<li><a href="../ref/array_elem.html">BOOST_PP_ARRAY_ELEM</a></li>
<li><a href="../ref/array_size.html">BOOST_PP_ARRAY_SIZE</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a href="http://www.housemarque.com"
target="_top">Housemarque Oy</a> 2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,46 +1,42 @@
<html>
<head>
<title>lists.html</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<h4>Lists</h4>
<div>
A <i>list</i> is a simple cons-style list with a head and a tail.&nbsp;
The head of a <i>list</i> is an element,
and the tail is either another <i>list</i> or <b>BOOST_PP_NIL</b>.
For example,
</div>
<div class="code">
(<i>a</i>, (<i>b</i>, (<i>c</i>, <b>BOOST_PP_NIL</b>)))
</div>
<div>
...is a <i>list</i> of <i>3</i> elements--<i>a</i>, <i>b</i>, and <i>c</i>.
</div>
<div>
This allows macro parameters to be variable in size and allows data states to change
size without the user explicitly keeping track of the size independently.
</div>
<div>
Elements of a <i>list</i> can be extracted with
<b>BOOST_PP_LIST_FIRST</b> and <b>BOOST_PP_LIST_REST</b>.&nbsp;
</div>
<h4>Primitives</h4>
<ul>
<li><a href="../ref/list_first.html">BOOST_PP_LIST_FIRST</a></li>
<li><a href="../ref/list_rest.html">BOOST_PP_LIST_REST</a></li>
<li><a href="../ref/nil.html">BOOST_PP_NIL</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>lists.html</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<h4>Lists</h4>
<div> A <i>list</i> is a simple cons-style list with a head and a
tail.&nbsp; The head of a <i>list</i> is an element, and the tail is
either another <i>list</i> or <b>BOOST_PP_NIL</b>. For example, </div>
<div class="code"> (<i>a</i>, (<i>b</i>, (<i>c</i>, <b>BOOST_PP_NIL</b>)))
</div>
<div> ...is a <i>list</i> of <i>3</i> elements--<i>a</i>, <i>b</i>, and <i>c</i>.
</div>
<div> This allows macro parameters to be variable in size and allows data
states to change size without the user explicitly keeping track of the
size independently.<br>
<br>
A list can be empty and therefore have a size of 0. An empty list is
represented by the notation <b>BOOST_PP_NIL.<br>
<br>
</b></div>
<div> Elements of a <i>list</i> can be extracted with <b>BOOST_PP_LIST_FIRST</b>
and <b>BOOST_PP_LIST_REST</b>.&nbsp; </div>
<h4>Primitives</h4>
<ul>
<li><a href="../ref/list_first.html">BOOST_PP_LIST_FIRST</a></li>
<li><a href="../ref/list_rest.html">BOOST_PP_LIST_REST</a></li>
<li><a href="../ref/nil.html">BOOST_PP_NIL</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a href="http://www.housemarque.com"
target="_top">Housemarque Oy</a> 2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,30 +1,23 @@
<html>
<head>
<title>sequences.html</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<h4>
Sequences
</h4>
<div>
A <i>sequence</i> (abbreviated to <i>seq</i>) is a group of adjacent parenthesized elements. For example,
</div>
<div class="code">
(<i>a</i>)(<i>b</i>)(<i>c</i>)
</div>
<div>
...is a <i>seq</i> of <i>3</i> elements--<i>a</i>, <i>b</i>, and <i>c</i>.
</div>
<div>
<i>Sequences</i> are data structures that merge the properties of both <i>lists</i> and
<i>tuples</i> with the exception that a <i>seq</i> cannot be empty.&nbsp;
Therefore, an "empty" <i>seq</i> is considered a special case scenario that
must be handled separately in C++.
</div>
<div class="code">
<pre>
#define SEQ (x)(y)(z)
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>sequences.html</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<h4> Sequences </h4>
<div> A <i>sequence</i> (abbreviated to <i>seq</i>) is a group of adjacent
parenthesized elements. For example, </div>
<div class="code"> (<i>a</i>)(<i>b</i>)(<i>c</i>) </div>
<div> ...is a <i>seq</i> of <i>3</i> elements--<i>a</i>, <i>b</i>, and <i>c</i>.
</div>
<div> <i>Sequences</i> are data structures that merge the properties of
both <i>lists</i> and <i>tuples</i> with the exception that a <i>seq, </i>like
a <i>tuple, </i>cannot be empty.&nbsp; Therefore, an "empty" <i>seq</i>
is considered a special case scenario that must be handled separately in
C++. </div>
<div class="code">
<pre>#define SEQ (x)(y)(z)
#define REVERSE(s, state, elem) (elem) state
// append to head ^
@ -41,35 +34,27 @@ BOOST_PP_SEQ_FOLD_RIGHT(INC, BOOST_PP_SEQ_NIL, SEQ)
// ^
// special placeholder that will be "eaten"
// by appending to the tail
</pre>
</div>
<div>
<i>Sequences</i> are extremely efficient.&nbsp; Element access speed approaches
random access--even with <i>seqs</i> of up to <i>256</i> elements.&nbsp; This
is because element access (among other things) is implemented iteratively
rather than recursively.&nbsp; Therefore, elements can be accessed at extremely
high indices even on preprocessors with low maximum expansion depths.
</div>
<div>
Elements of a <i>seq</i> can be extracted with <b>BOOST_PP_SEQ_ELEM</b>.
</div>
<h4>
Primitives
</h4>
<ul>
<li>
<a href="../ref/seq_elem.html">BOOST_PP_SEQ_ELEM</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</pre> </div>
<div> <i>Sequences</i> are extremely efficient.&nbsp; Element access speed
approaches random access--even with <i>seqs</i> of up to <i>256</i>
elements.&nbsp; This is because element access (among other things) is
implemented iteratively rather than recursively.&nbsp; Therefore, elements
can be accessed at extremely high indices even on preprocessors with low
maximum expansion depths. </div>
<div> Elements of a <i>seq</i> can be extracted with <b>BOOST_PP_SEQ_ELEM</b>.
</div>
<h4> Primitives </h4>
<ul>
<li> <a href="../ref/seq_elem.html">BOOST_PP_SEQ_ELEM</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a href="http://www.housemarque.com"
target="_top">Housemarque Oy</a> 2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,42 +1,40 @@
<html>
<head>
<title>tuples.html</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<h4>Tuples</h4>
<div>
A <i>tuple</i> is a simple comma-separated list of elements inside parenthesis.&nbsp;
For example,
</div>
<div class="code">
(<i>a</i>, <i>b</i>, <i>c</i>)
</div>
<div>
...is a <i>tuple</i> of <i>3</i> elements--<i>a</i>, <i>b</i>, and <i>c</i>.
</div>
<div>
<i>Tuples</i> are fast and easy to use.&nbsp;
However, all access to <i>tuples</i> requires knowledge of its size.
</div>
<div>
Elements of a <i>tuple</i> can be extracted with
<b>BOOST_PP_TUPLE_ELEM</b>.
</div>
<h4>Primitives</h4>
<ul>
<li><a href="../ref/tuple_elem.html">BOOST_PP_TUPLE_ELEM</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>tuples.html</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<h4>Tuples</h4>
<div> A <i>tuple</i> is a simple comma-separated list of elements inside
parenthesis.&nbsp; For example, </div>
<div class="code"> (<i>a</i>, <i>b</i>, <i>c</i>) </div>
<div> ...is a <i>tuple</i> of <i>3</i> elements--<i>a</i>, <i>b</i>, and
<i>c</i>.<br>
<br>
A <i>tuple </i>cannot be empty. The notation '()' as a <i>tuple </i>is
a single element <i>tuple </i>of size 1, where the element is empty. </div>
<div> <i>Tuples</i> are fast and easy to use.&nbsp; With variadic macro
support it is not necessary to know the size of a <i>tuple</i>.
Use a <i>tuple </i>instead of an <i>array</i>, since a <i>tuple </i>has all of
the functionality as an <i>array </i>and is easier syntactically to use.
The only functionality an <i>array </i>has which a <i>tuple </i>does
not have is that an <i>array </i>can be empty whereas a <i>tuple </i>cannot
be empty.</div>
<div> Elements of a <i>tuple</i> can be extracted with <b>BOOST_PP_TUPLE_ELEM</b>.
</div>
<h4>Primitives</h4>
<ul>
<li><a href="../ref/tuple_elem.html">BOOST_PP_TUPLE_ELEM</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a href="http://www.housemarque.com"
target="_top">Housemarque Oy</a> 2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,216 +1,254 @@
<html>
<head>
<title>headers.html</title>
<link rel="stylesheet" type="text/css" href="styles.css">
<base target="desc">
<style>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>headers.html</title>
<link rel="stylesheet" type="text/css" href="styles.css">
<base target="desc">
<style>
.ps { margin-left: 30px; }
</style>
</head>
<body>
<h4>
Headers <small><a href="contents.html" target="index">[back]</a></small>
</h4>
<ul>
<li>../</li>
<li class="ps">
<a href="headers/preprocessor.html">preprocessor.hpp</a></li>
<li><a href="headers/arithmetic.html">arithmetic.hpp</a></li>
<li>arithmetic/</li>
<li class="ps"><a href="headers/arithmetic/add.html">add.hpp</a></li>
<li class="ps"><a href="headers/arithmetic/dec.html">dec.hpp</a></li>
<li class="ps"><a href="headers/arithmetic/div.html">div.hpp</a></li>
<li class="ps"><a href="headers/arithmetic/inc.html">inc.hpp</a></li>
<li class="ps"><a href="headers/arithmetic/mod.html">mod.hpp</a></li>
<li class="ps"><a href="headers/arithmetic/mul.html">mul.hpp</a></li>
<li class="ps"><a href="headers/arithmetic/sub.html">sub.hpp</a></li>
<li><a href="headers/array.html">array.hpp</a></li>
<li>array/</li>
<li class="ps"><a href="headers/array/data.html">data.hpp</a></li>
<li class="ps"><a href="headers/array/elem.html">elem.hpp</a></li>
<li class="ps"><a href="headers/array/insert.html">insert.hpp</a></li>
<li class="ps"><a href="headers/array/pop_back.html">pop_back.hpp</a></li>
<li class="ps"><a href="headers/array/pop_front.html">pop_front.hpp</a></li>
<li class="ps"><a href="headers/array/push_back.html">push_back.hpp</a></li>
<li class="ps"><a href="headers/array/push_front.html">push_front.hpp</a></li>
<li class="ps"><a href="headers/array/remove.html">remove.hpp</a></li>
<li class="ps"><a href="headers/array/replace.html">replace.hpp</a></li>
<li class="ps"><a href="headers/array/reverse.html">reverse.hpp</a></li>
<li class="ps"><a href="headers/array/size.html">size.hpp</a></li>
<li><a href="headers/assert_msg.html">assert_msg.hpp*</a></li>
<li><a href="headers/cat.html">cat.hpp</a></li>
<li><a href="headers/comma.html">comma.hpp*</a></li>
<li><a href="headers/comma_if.html">comma_if.hpp*</a></li>
<li><a href="headers/comparison.html">comparison.hpp</a></li>
<li>comparison/</li>
<li class="ps"><a href="headers/comparison/equal.html">equal.hpp</a></li>
<li class="ps"><a href="headers/comparison/greater.html">greater.hpp</a></li>
<li class="ps"><a href="headers/comparison/greater_equal.html">greater_equal.hpp</a></li>
<li class="ps"><a href="headers/comparison/less.html">less.hpp</a></li>
<li class="ps"><a href="headers/comparison/less_equal.html">less_equal.hpp</a></li>
<li class="ps"><a href="headers/comparison/not_equal.html">not_equal.hpp</a></li>
<li>config/</li>
<li class="ps"><a href="headers/config/limits.html">limits.hpp</a></li>
<li><a href="headers/control.html">control.hpp</a></li>
<li>control/</li>
<li class="ps"><a href="headers/control/deduce_d.html">deduce_d.hpp</a></li>
<li class="ps"><a href="headers/control/expr_if.html">expr_if.hpp</a></li>
<li class="ps"><a href="headers/control/expr_iif.html">expr_iif.hpp</a></li>
<li class="ps"><a href="headers/control/if.html">if.hpp</a></li>
<li class="ps"><a href="headers/control/iif.html">iif.hpp</a></li>
<li class="ps"><a href="headers/control/while.html">while.hpp</a></li>
<li><a href="headers/debug.html">debug.hpp</a></li>
<li>debug/</li>
<li class="ps"><a href="headers/debug/assert.html">assert.hpp</a></li>
<li class="ps"><a href="headers/debug/line.html">line.hpp</a></li>
<li><a href="headers/dec.html">dec.hpp*</a></li>
<li><a href="headers/empty.html">empty.hpp*</a></li>
<li><a href="headers/enum.html">enum.hpp*</a></li>
<li><a href="headers/enum_params.html">enum_params.hpp*</a></li>
<li><a href="headers/epwad.html">enum_params_with_a_default.hpp*</a></li>
<li><a href="headers/epwd.html">enum_params_with_defaults.hpp*</a></li>
<li><a href="headers/enum_shifted.html">enum_shifted.hpp*</a></li>
<li><a href="headers/enum_shifted_params.html">enum_shifted_params.hpp*</a></li>
<li><a href="headers/expand.html">expand.hpp*</a></li>
<li><a href="headers/expr_if.html">expr_if.hpp*</a></li>
<li><a href="headers/facilities.html">facilities.hpp</a></li>
<li>facilities/</li>
<li class="ps"><a href="headers/facilities/apply.html">apply.hpp</a></li>
<li class="ps"><a href="headers/facilities/empty.html">empty.hpp</a></li>
<li class="ps"><a href="headers/facilities/expand.html">expand.hpp</a></li>
<li class="ps"><a href="headers/facilities/identity.html">identity.hpp</a></li>
<li class="ps"><a href="headers/facilities/intercept.html">intercept.hpp</a></li>
<li><a href="headers/for.html">for.hpp*</a></li>
<li><a href="headers/identity.html">identity.hpp*</a></li>
<li><a href="headers/if.html">if.hpp*</a></li>
<li><a href="headers/inc.html">inc.hpp*</a></li>
<li><a href="headers/iterate.html">iterate.hpp*</a></li>
<li><a href="headers/iteration.html">iteration.hpp</a></li>
<li>iteration/</li>
<li class="ps"><a href="headers/iteration/iterate.html">iterate.hpp</a></li>
<li class="ps"><a href="headers/iteration/local.html">local.hpp</a></li>
<li class="ps"><a href="headers/iteration/self.html">self.hpp</a></li>
<li><a href="headers/library.html">library.hpp</a></li>
<li><a href="headers/limits.html">limits.hpp*</a></li>
<li><a href="headers/list.html">list.hpp</a></li>
<li>list/</li>
<li class="ps"><a href="headers/list/adt.html">adt.hpp</a></li>
<li class="ps"><a href="headers/list/append.html">append.hpp</a></li>
<li class="ps"><a href="headers/list/at.html">at.hpp</a></li>
<li class="ps"><a href="headers/list/cat.html">cat.hpp</a></li>
<li class="ps"><a href="headers/list/enum.html">enum.hpp</a></li>
<li class="ps"><a href="headers/list/filter.html">filter.hpp</a></li>
<li class="ps"><a href="headers/list/first_n.html">first_n.hpp</a></li>
<li class="ps"><a href="headers/list/fold_left.html">fold_left.hpp</a></li>
<li class="ps"><a href="headers/list/fold_right.html">fold_right.hpp</a></li>
<li class="ps"><a href="headers/list/for_each.html">for_each.hpp</a></li>
<li class="ps"><a href="headers/list/for_each_i.html">for_each_i.hpp</a></li>
<li class="ps"><a href="headers/list/for_each_product.html">for_each_product.hpp</a></li>
<li class="ps"><a href="headers/list/rest_n.html">rest_n.hpp</a></li>
<li class="ps"><a href="headers/list/reverse.html">reverse.hpp</a></li>
<li class="ps"><a href="headers/list/size.html">size.hpp</a></li>
<li class="ps"><a href="headers/list/to_tuple.html">to_tuple.hpp</a></li>
<li class="ps"><a href="headers/list/transform.html">transform.hpp</a></li>
<li><a href="headers/logical.html">logical.hpp</a></li>
<li>logical/</li>
<li class="ps"><a href="headers/logical/and.html">and.hpp</a></li>
<li class="ps"><a href="headers/logical/bitand.html">bitand.hpp</a></li>
<li class="ps"><a href="headers/logical/bitnor.html">bitnor.hpp</a></li>
<li class="ps"><a href="headers/logical/bitor.html">bitor.hpp</a></li>
<li class="ps"><a href="headers/logical/bitxor.html">bitxor.hpp</a></li>
<li class="ps"><a href="headers/logical/bool.html">bool.hpp</a></li>
<li class="ps"><a href="headers/logical/compl.html">compl.hpp</a></li>
<li class="ps"><a href="headers/logical/nor.html">nor.hpp</a></li>
<li class="ps"><a href="headers/logical/not.html">not.hpp</a></li>
<li class="ps"><a href="headers/logical/or.html">or.hpp</a></li>
<li class="ps"><a href="headers/logical/xor.html">xor.hpp</a></li>
<li><a href="headers/max.html">max.hpp*</a></li>
<li><a href="headers/min.html">min.hpp*</a></li>
<li><a href="headers/punctuation.html">punctuation.hpp</a></li>
<li>punctuation/</li>
<li class="ps"><a href="headers/punctuation/comma.html">comma.hpp</a></li>
<li class="ps"><a href="headers/punctuation/comma_if.html">comma_if.hpp</a></li>
<li class="ps"><a href="headers/punctuation/paren.html">paren.hpp</a></li>
<li class="ps"><a href="headers/punctuation/paren_if.html">paren_if.hpp</a></li>
<li><a href="headers/repeat.html">repeat.hpp*</a></li>
<li><a href="headers/repeat_2nd.html">repeat_2nd.hpp*</a></li>
<li><a href="headers/repeat_3rd.html">repeat_3rd.hpp*</a></li>
<li><a href="headers/repeat_from_to.html">repeat_from_to.hpp*</a></li>
<li><a href="headers/repeat_from_to_2nd.html">repeat_from_to_2nd.hpp*</a></li>
<li><a href="headers/repeat_from_to_3rd.html">repeat_from_to_3rd.hpp*</a></li>
<li><a href="headers/repetition.html">repetition.hpp</a></li>
<li>repetition/</li>
<li class="ps"><a href="headers/repetition/deduce_r.html">deduce_r.hpp</a></li>
<li class="ps"><a href="headers/repetition/deduce_z.html">deduce_z.hpp</a></li>
<li class="ps"><a href="headers/repetition/enum.html">enum.hpp</a></li>
<li class="ps"><a href="headers/repetition/enum_binary_params.html">enum_binary_params.hpp</a></li>
<li class="ps"><a href="headers/repetition/enum_params.html">enum_params.hpp</a></li>
<li class="ps"><a href="headers/repetition/epwad.html">enum_params_with_a_default.hpp</a></li>
<li class="ps"><a href="headers/repetition/epwd.html">enum_params_with_defaults.hpp</a></li>
<li class="ps"><a href="headers/repetition/esbp.html">enum_shifted_binary_params.hpp</a></li>
<li class="ps"><a href="headers/repetition/enum_shifted_params.html">enum_shifted_params.hpp</a></li>
<li class="ps"><a href="headers/repetition/enum_shifted.html">enum_shifted.hpp</a></li>
<li class="ps"><a href="headers/repetition/enum_trailing.html">enum_trailing.hpp</a></li>
<li class="ps"><a href="headers/repetition/etbp.html">enum_trailing_binary_params.hpp</a></li>
<li class="ps"><a href="headers/repetition/enum_trailing_params.html">enum_trailing_params.hpp</a></li>
<li class="ps"><a href="headers/repetition/for.html">for.hpp</a></li>
<li class="ps"><a href="headers/repetition/repeat.html">repeat.hpp</a></li>
<li class="ps"><a href="headers/repetition/repeat_from_to.html">repeat_from_to.hpp</a></li>
<li><a href="headers/selection.html">selection.hpp</a></li>
<li>selection/</li>
<li class="ps"><a href="headers/selection/max.html">max.hpp</a></li>
<li class="ps"><a href="headers/selection/min.html">min.hpp</a></li>
<li><a href="headers/seq.html">seq.hpp</a></li>
<li>seq/</li>
<li class="ps"><a href="headers/seq/cat.html">cat.hpp</a></li>
<li class="ps"><a href="headers/seq/elem.html">elem.hpp</a></li>
<li class="ps"><a href="headers/seq/enum.html">enum.hpp</a></li>
<li class="ps"><a href="headers/seq/filter.html">filter.hpp</a></li>
<li class="ps"><a href="headers/seq/first_n.html">first_n.hpp</a></li>
<li class="ps"><a href="headers/seq/fold_left.html">fold_left.hpp</a></li>
<li class="ps"><a href="headers/seq/fold_right.html">fold_right.hpp</a></li>
<li class="ps"><a href="headers/seq/for_each.html">for_each.hpp</a></li>
<li class="ps"><a href="headers/seq/for_each_i.html">for_each_i.hpp</a></li>
<li class="ps"><a href="headers/seq/for_each_product.html">for_each_product.hpp</a></li>
<li class="ps"><a href="headers/seq/insert.html">insert.hpp</a></li>
<li class="ps"><a href="headers/seq/pop_back.html">pop_back.hpp</a></li>
<li class="ps"><a href="headers/seq/pop_front.html">pop_front.hpp</a></li>
<li class="ps"><a href="headers/seq/push_back.html">push_back.hpp</a></li>
<li class="ps"><a href="headers/seq/push_front.html">push_front.hpp</a></li>
<li class="ps"><a href="headers/seq/remove.html">remove.hpp</a></li>
<li class="ps"><a href="headers/seq/replace.html">replace.hpp</a></li>
<li class="ps"><a href="headers/seq/rest_n.html">rest_n.hpp</a></li>
<li class="ps"><a href="headers/seq/reverse.html">reverse.hpp</a></li>
<li class="ps"><a href="headers/seq/seq.html">seq.hpp</a></li>
<li class="ps"><a href="headers/seq/size.html">size.hpp</a></li>
<li class="ps"><a href="headers/seq/subseq.html">subseq.hpp</a></li>
<li class="ps"><a href="headers/seq/to_array.html">to_array.hpp</a></li>
<li class="ps"><a href="headers/seq/to_tuple.html">to_tuple.hpp</a></li>
<li class="ps"><a href="headers/seq/transform.html">transform.hpp</a></li>
<li><a href="headers/slot.html">slot.hpp</a></li>
<li>slot/</li>
<li class="ps"><a href="headers/slot/counter.html">counter.hpp</a></li>
<li class="ps"><a href="headers/slot/slot.html">slot.hpp</a></li>
<li><a href="headers/tuple.html">tuple.hpp</a></li>
<li>tuple/</li>
<li class="ps"><a href="headers/tuple/elem.html">elem.hpp</a></li>
<li class="ps"><a href="headers/tuple/eat.html">eat.hpp</a></li>
<li class="ps"><a href="headers/tuple/rem.html">rem.hpp</a></li>
<li class="ps"><a href="headers/tuple/reverse.html">reverse.hpp</a></li>
<li class="ps"><a href="headers/tuple/to_list.html">to_list.hpp</a></li>
<li class="ps"><a href="headers/tuple/to_seq.html">to_seq.hpp</a></li>
<li><a href="headers/stringize.html">stringize.hpp</a></li>
<li><a href="headers/while.html">while.hpp*</a></li>
<li><a href="headers/wstringize.html">wstringize.hpp</a></li>
</ul>
<!--
<EFBFBD> Copyright Housemarque Oy 2002
<EFBFBD> Copyright Paul Mensonides 2002
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)
-->
</body>
</style>
</head>
<body>
<h4> Headers <small><a href="contents.html" target="index">[back]</a></small>
</h4>
<ul>
<li>../</li>
<li class="ps"> <a href="headers/preprocessor.html">preprocessor.hpp</a></li>
<li><a href="headers/arithmetic.html">arithmetic.hpp</a></li>
<li>arithmetic/</li>
<li class="ps"><a href="headers/arithmetic/add.html">add.hpp</a></li>
<li class="ps"><a href="headers/arithmetic/dec.html">dec.hpp</a></li>
<li class="ps"><a href="headers/arithmetic/div.html">div.hpp</a></li>
<li class="ps"><a href="headers/arithmetic/inc.html">inc.hpp</a></li>
<li class="ps"><a href="headers/arithmetic/mod.html">mod.hpp</a></li>
<li class="ps"><a href="headers/arithmetic/mul.html">mul.hpp</a></li>
<li class="ps"><a href="headers/arithmetic/sub.html">sub.hpp</a></li>
<li><a href="headers/array.html">array.hpp</a></li>
<li>array/</li>
<li class="ps"><a href="headers/array/data.html">data.hpp</a></li>
<li class="ps"><a href="headers/array/elem.html">elem.hpp</a></li>
<li class="ps"><a href="headers/array/enum.html">enum.hpp</a></li>
<li class="ps"><a href="headers/array/insert.html">insert.hpp</a></li>
<li class="ps"><a href="headers/array/pop_back.html">pop_back.hpp</a></li>
<li class="ps"><a href="headers/array/pop_front.html">pop_front.hpp</a></li>
<li class="ps"><a href="headers/array/push_back.html">push_back.hpp</a></li>
<li class="ps"><a href="headers/array/push_front.html">push_front.hpp</a></li>
<li class="ps"><a href="headers/array/remove.html">remove.hpp</a></li>
<li class="ps"><a href="headers/array/replace.html">replace.hpp</a></li>
<li class="ps"><a href="headers/array/reverse.html">reverse.hpp</a></li>
<li class="ps"><a href="headers/array/size.html">size.hpp</a></li>
<li class="ps"><a href="headers/array/to_list.html">to_list.hpp</a></li>
<li class="ps"><a href="headers/array/to_seq.html">to_seq.hpp</a></li>
<li class="ps"><a href="headers/array/to_tuple.html">to_tuple.hpp</a></li>
<li><a href="headers/assert_msg.html">assert_msg.hpp*</a></li>
<li><a href="headers/cat.html">cat.hpp</a></li>
<li><a href="headers/comma.html">comma.hpp*</a></li>
<li><a href="headers/comma_if.html">comma_if.hpp*</a></li>
<li><a href="headers/comparison.html">comparison.hpp</a></li>
<li>comparison/</li>
<li class="ps"><a href="headers/comparison/equal.html">equal.hpp</a></li>
<li class="ps"><a href="headers/comparison/greater.html">greater.hpp</a></li>
<li class="ps"><a href="headers/comparison/greater_equal.html">greater_equal.hpp</a></li>
<li class="ps"><a href="headers/comparison/less.html">less.hpp</a></li>
<li class="ps"><a href="headers/comparison/less_equal.html">less_equal.hpp</a></li>
<li class="ps"><a href="headers/comparison/not_equal.html">not_equal.hpp</a></li>
<li>config/</li>
<li class="ps"><a href="headers/config/limits.html">limits.hpp</a></li>
<li class="ps"><a href="headers/config/variadics.html">config.hpp</a></li>
<li><a href="headers/control.html">control.hpp</a></li>
<li>control/</li>
<li class="ps"><a href="headers/control/deduce_d.html">deduce_d.hpp</a></li>
<li class="ps"><a href="headers/control/expr_if.html">expr_if.hpp</a></li>
<li class="ps"><a href="headers/control/expr_iif.html">expr_iif.hpp</a></li>
<li class="ps"><a href="headers/control/if.html">if.hpp</a></li>
<li class="ps"><a href="headers/control/iif.html">iif.hpp</a></li>
<li class="ps"><a href="headers/control/while.html">while.hpp</a></li>
<li><a href="headers/debug.html">debug.hpp</a></li>
<li>debug/</li>
<li class="ps"><a href="headers/debug/assert.html">assert.hpp</a></li>
<li class="ps"><a href="headers/debug/line.html">line.hpp</a></li>
<li><a href="headers/dec.html">dec.hpp*</a></li>
<li><a href="headers/empty.html">empty.hpp*</a></li>
<li><a href="headers/enum.html">enum.hpp*</a></li>
<li><a href="headers/enum_params.html">enum_params.hpp*</a></li>
<li><a href="headers/epwad.html">enum_params_with_a_default.hpp*</a></li>
<li><a href="headers/epwd.html">enum_params_with_defaults.hpp*</a></li>
<li><a href="headers/enum_shifted.html">enum_shifted.hpp*</a></li>
<li><a href="headers/enum_shifted_params.html">enum_shifted_params.hpp*</a></li>
<li><a href="headers/expand.html">expand.hpp*</a></li>
<li><a href="headers/expr_if.html">expr_if.hpp*</a></li>
<li><a href="headers/facilities.html">facilities.hpp</a></li>
<li>facilities/</li>
<li class="ps"><a href="headers/facilities/apply.html">apply.hpp</a></li>
<li class="ps"><a href="headers/facilities/check_empty.html">check_empty.hpp</a>
<a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/facilities/empty.html">empty.hpp</a></li>
<li class="ps"><a href="headers/facilities/expand.html">expand.hpp</a></li>
<li class="ps"><a href="headers/facilities/identity.html">identity.hpp</a></li>
<li class="ps"><a href="headers/facilities/intercept.html">intercept.hpp</a></li>
<li class="ps"><a href="headers/facilities/overload.html">overload.hpp</a>
<a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/facilities/va_opt.html">va_opt.hpp</a>
<a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="headers/for.html">for.hpp*</a></li>
<li><a href="headers/identity.html">identity.hpp*</a></li>
<li><a href="headers/if.html">if.hpp*</a></li>
<li><a href="headers/inc.html">inc.hpp*</a></li>
<li><a href="headers/iterate.html">iterate.hpp*</a></li>
<li><a href="headers/iteration.html">iteration.hpp</a></li>
<li>iteration/</li>
<li class="ps"><a href="headers/iteration/iterate.html">iterate.hpp</a></li>
<li class="ps"><a href="headers/iteration/local.html">local.hpp</a></li>
<li class="ps"><a href="headers/iteration/self.html">self.hpp</a></li>
<li><a href="headers/library.html">library.hpp</a></li>
<li><a href="headers/limits.html">limits.hpp*</a></li>
<li><a href="headers/list.html">list.hpp</a></li>
<li>list/</li>
<li class="ps"><a href="headers/list/adt.html">adt.hpp</a></li>
<li class="ps"><a href="headers/list/append.html">append.hpp</a></li>
<li class="ps"><a href="headers/list/at.html">at.hpp</a></li>
<li class="ps"><a href="headers/list/cat.html">cat.hpp</a></li>
<li class="ps"><a href="headers/list/enum.html">enum.hpp</a></li>
<li class="ps"><a href="headers/list/filter.html">filter.hpp</a></li>
<li class="ps"><a href="headers/list/first_n.html">first_n.hpp</a></li>
<li class="ps"><a href="headers/list/fold_left.html">fold_left.hpp</a></li>
<li class="ps"><a href="headers/list/fold_right.html">fold_right.hpp</a></li>
<li class="ps"><a href="headers/list/for_each.html">for_each.hpp</a></li>
<li class="ps"><a href="headers/list/for_each_i.html">for_each_i.hpp</a></li>
<li class="ps"><a href="headers/list/for_each_product.html">for_each_product.hpp</a></li>
<li class="ps"><a href="headers/list/rest_n.html">rest_n.hpp</a></li>
<li class="ps"><a href="headers/list/reverse.html">reverse.hpp</a></li>
<li class="ps"><a href="headers/list/size.html">size.hpp</a></li>
<li class="ps"><a href="headers/list/to_array.html">to_array.hpp</a></li>
<li class="ps"><a href="headers/list/to_seq.html">to_seq.hpp</a></li>
<li class="ps"><a href="headers/list/to_tuple.html">to_tuple.hpp</a></li>
<li class="ps"><a href="headers/list/transform.html">transform.hpp</a></li>
<li><a href="headers/logical.html">logical.hpp</a></li>
<li>logical/</li>
<li class="ps"><a href="headers/logical/and.html">and.hpp</a></li>
<li class="ps"><a href="headers/logical/bitand.html">bitand.hpp</a></li>
<li class="ps"><a href="headers/logical/bitnor.html">bitnor.hpp</a></li>
<li class="ps"><a href="headers/logical/bitor.html">bitor.hpp</a></li>
<li class="ps"><a href="headers/logical/bitxor.html">bitxor.hpp</a></li>
<li class="ps"><a href="headers/logical/bool.html">bool.hpp</a></li>
<li class="ps"><a href="headers/logical/compl.html">compl.hpp</a></li>
<li class="ps"><a href="headers/logical/nor.html">nor.hpp</a></li>
<li class="ps"><a href="headers/logical/not.html">not.hpp</a></li>
<li class="ps"><a href="headers/logical/or.html">or.hpp</a></li>
<li class="ps"><a href="headers/logical/xor.html">xor.hpp</a></li>
<li><a href="headers/max.html">max.hpp*</a></li>
<li><a href="headers/min.html">min.hpp*</a></li>
<li><a href="headers/punctuation.html">punctuation.hpp</a></li>
<li>punctuation/</li>
<li class="ps"><a href="headers/punctuation/comma.html">comma.hpp</a></li>
<li class="ps"><a href="headers/punctuation/comma_if.html">comma_if.hpp</a></li>
<li class="ps"><a href="headers/punctuation/is_begin_parens.html">is_begin_parens.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/punctuation/paren.html">paren.hpp</a></li>
<li class="ps"><a href="headers/punctuation/paren_if.html">paren_if.hpp</a></li>
<li class="ps"><a href="headers/punctuation/remove_parens.html">remove_parens.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="headers/repeat.html">repeat.hpp*</a></li>
<li><a href="headers/repeat_2nd.html">repeat_2nd.hpp*</a></li>
<li><a href="headers/repeat_3rd.html">repeat_3rd.hpp*</a></li>
<li><a href="headers/repeat_from_to.html">repeat_from_to.hpp*</a></li>
<li><a href="headers/repeat_from_to_2nd.html">repeat_from_to_2nd.hpp*</a></li>
<li><a href="headers/repeat_from_to_3rd.html">repeat_from_to_3rd.hpp*</a></li>
<li><a href="headers/repetition.html">repetition.hpp</a></li>
<li>repetition/</li>
<li class="ps"><a href="headers/repetition/deduce_r.html">deduce_r.hpp</a></li>
<li class="ps"><a href="headers/repetition/deduce_z.html">deduce_z.hpp</a></li>
<li class="ps"><a href="headers/repetition/enum.html">enum.hpp</a></li>
<li class="ps"><a href="headers/repetition/enum_binary_params.html">enum_binary_params.hpp</a></li>
<li class="ps"><a href="headers/repetition/enum_params.html">enum_params.hpp</a></li>
<li class="ps"><a href="headers/repetition/epwad.html">enum_params_with_a_default.hpp</a></li>
<li class="ps"><a href="headers/repetition/epwd.html">enum_params_with_defaults.hpp</a></li>
<li class="ps"><a href="headers/repetition/esbp.html">enum_shifted_binary_params.hpp</a></li>
<li class="ps"><a href="headers/repetition/enum_shifted_params.html">enum_shifted_params.hpp</a></li>
<li class="ps"><a href="headers/repetition/enum_shifted.html">enum_shifted.hpp</a></li>
<li class="ps"><a href="headers/repetition/enum_trailing.html">enum_trailing.hpp</a></li>
<li class="ps"><a href="headers/repetition/etbp.html">enum_trailing_binary_params.hpp</a></li>
<li class="ps"><a href="headers/repetition/enum_trailing_params.html">enum_trailing_params.hpp</a></li>
<li class="ps"><a href="headers/repetition/for.html">for.hpp</a></li>
<li class="ps"><a href="headers/repetition/repeat.html">repeat.hpp</a></li>
<li class="ps"><a href="headers/repetition/repeat_from_to.html">repeat_from_to.hpp</a></li>
<li><a href="headers/selection.html">selection.hpp</a></li>
<li>selection/</li>
<li class="ps"><a href="headers/selection/max.html">max.hpp</a></li>
<li class="ps"><a href="headers/selection/min.html">min.hpp</a></li>
<li><a href="headers/seq.html">seq.hpp</a></li>
<li>seq/</li>
<li class="ps"><a href="headers/seq/cat.html">cat.hpp</a></li>
<li class="ps"><a href="headers/seq/elem.html">elem.hpp</a></li>
<li class="ps"><a href="headers/seq/enum.html">enum.hpp</a></li>
<li class="ps"><a href="headers/seq/filter.html">filter.hpp</a></li>
<li class="ps"><a href="headers/seq/first_n.html">first_n.hpp</a></li>
<li class="ps"><a href="headers/seq/fold_left.html">fold_left.hpp</a></li>
<li class="ps"><a href="headers/seq/fold_right.html">fold_right.hpp</a></li>
<li class="ps"><a href="headers/seq/for_each.html">for_each.hpp</a></li>
<li class="ps"><a href="headers/seq/for_each_i.html">for_each_i.hpp</a></li>
<li class="ps"><a href="headers/seq/for_each_product.html">for_each_product.hpp</a></li>
<li class="ps"><a href="headers/seq/insert.html">insert.hpp</a></li>
<li class="ps"><a href="headers/seq/pop_back.html">pop_back.hpp</a></li>
<li class="ps"><a href="headers/seq/pop_front.html">pop_front.hpp</a></li>
<li class="ps"><a href="headers/seq/push_back.html">push_back.hpp</a></li>
<li class="ps"><a href="headers/seq/push_front.html">push_front.hpp</a></li>
<li class="ps"><a href="headers/seq/remove.html">remove.hpp</a></li>
<li class="ps"><a href="headers/seq/replace.html">replace.hpp</a></li>
<li class="ps"><a href="headers/seq/rest_n.html">rest_n.hpp</a></li>
<li class="ps"><a href="headers/seq/reverse.html">reverse.hpp</a></li>
<li class="ps"><a href="headers/seq/seq.html">seq.hpp</a></li>
<li class="ps"><a href="headers/seq/size.html">size.hpp</a></li>
<li class="ps"><a href="headers/seq/subseq.html">subseq.hpp</a></li>
<li class="ps"><a href="headers/seq/to_array.html">to_array.hpp</a></li>
<li class="ps"><a href="headers/seq/to_list.html">to_list.hpp</a></li>
<li class="ps"><a href="headers/seq/to_tuple.html">to_tuple.hpp</a></li>
<li class="ps"><a href="headers/seq/transform.html">transform.hpp</a></li>
<li class="ps"><a href="headers/seq/variadic_seq_to_seq.html">variadic_seq_to_seq.hpp</a></li>
<li><a href="headers/slot.html">slot.hpp</a></li>
<li>slot/</li>
<li class="ps"><a href="headers/slot/counter.html">counter.hpp</a></li>
<li class="ps"><a href="headers/slot/slot.html">slot.hpp</a></li>
<li><a href="headers/tuple.html">tuple.hpp</a></li>
<li>tuple/</li>
<li class="ps"><a href="headers/tuple/eat.html">eat.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/elem.html">elem.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/enum.html">enum.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/insert.html">insert.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/pop_back.html">pop_back.hpp</a> <a
href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/pop_front.html">pop_front.hpp</a> <a
href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/push_back.html">push_back.hpp</a> <a
href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/push_front.html">push_front.hpp</a>
<a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/rem.html">rem.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/remove.html">remove.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/replace.html">replace.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/reverse.html">reverse.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/size.html">size.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/to_array.html">to_array.hpp</a> <a
href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/to_list.html">to_list.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/tuple/to_seq.html">to_seq.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="headers/stringize.html">stringize.hpp</a></li>
<li><a href="headers/variadic.html">variadic.hpp</a></li>
<li>variadic/</li>
<li class="ps"><a href="headers/variadic/elem.html">elem.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/variadic/has_opt.html">has_opt.hpp</a> </li>
<li class="ps"><a href="headers/variadic/size.html">size.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/variadic/to_array.html">to_array.hpp</a> <a
href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/variadic/to_list.html">to_list.hpp</a> <a
href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/variadic/to_seq.html">to_seq.hpp</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li class="ps"><a href="headers/variadic/to_tuple.html">to_tuple.hpp</a> <a
href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="headers/while.html">while.hpp*</a></li>
<li><a href="headers/wstringize.html">wstringize.hpp</a></li>
</ul>
<!--
<EFBFBD> Copyright Housemarque Oy 2002<30> Copyright Paul Mensonides 2002
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)-->
</body>
</html>

View File

@ -1,10 +1,10 @@
<html>
<head>
<title>array.hpp</title>
<title>array.hpp</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
<div style="margin-left: 0px;">
The <b>array.hpp</b> includes the headers in the <i>array</i> folder.
</div>
<h4>Usage</h4>
@ -15,6 +15,7 @@
<ul>
<li><a href="array/data.html">&lt;boost/preprocessor/array/data.hpp&gt;</a></li>
<li><a href="array/elem.html">&lt;boost/preprocessor/array/elem.hpp&gt;</a></li>
<li><a href="array/enum.html">&lt;boost/preprocessor/array/enum.hpp&gt;</a></li>
<li><a href="array/insert.html">&lt;boost/preprocessor/array/insert.hpp&gt;</a></li>
<li><a href="array/pop_back.html">&lt;boost/preprocessor/array/pop_back.hpp&gt;</a></li>
<li><a href="array/pop_front.html">&lt;boost/preprocessor/array/pop_front.hpp&gt;</a></li>
@ -24,17 +25,19 @@
<li><a href="array/replace.html">&lt;boost/preprocessor/array/replace.hpp&gt;</a></li>
<li><a href="array/reverse.html">&lt;boost/preprocessor/array/reverse.hpp&gt;</a></li>
<li><a href="array/size.html">&lt;boost/preprocessor/array/size.hpp&gt;</a></li>
<li><a href="array/to_list.html">&lt;boost/preprocessor/array/to_list.hpp&gt;</a></li>
<li><a href="array/to_seq.html">&lt;boost/preprocessor/array/to_seq.hpp&gt;</a></li>
<li><a href="array/to_tuple.html">&lt;boost/preprocessor/array/to_tuple.hpp&gt;</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
<br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,24 @@
<html>
<head>
<title>array/enum.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>array/enum.hpp</b> header
defines a macro to convert an <i>array</i> to its comma-separated elements. </div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/array/enum.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/array_enum.html">BOOST_PP_ARRAY_ENUM</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i></i><i><EFBFBD> Copyright Edward Diener 2011</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0.
(See accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,24 @@
<html>
<head>
<title>array/to_list.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>array/to_list.hpp</b> header
defines a macro that converts an <i>array</i> to a <i>list</i>. </div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/array/to_list.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/array_to_list.html">BOOST_PP_ARRAY_TO_LIST</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i></i><i><EFBFBD> Copyright Edward Diener 2011</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0.
(See accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,24 @@
<html>
<head>
<title>array/to_seq.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>array/to_seq.hpp</b> header
defines a macro that converts an <i>array</i> to a <i>seq.</i> </div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/array/to_seq.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/array_to_seq.html">BOOST_PP_ARRAY_TO_SEQ</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i></i><i><EFBFBD> Copyright Edward Diener 2011</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0.
(See accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,24 @@
<html>
<head>
<title>array/to_tuple.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>array/to_tuple.hpp</b> header
defines a macro that converts an <i>array </i>to a <i>tuple</i>. </div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/array/to_tuple.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/array_to_tuple.html">BOOST_PP_ARRAY_TO_TUPLE</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i></i><i><EFBFBD> Copyright Edward Diener 2011</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0.
(See accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,44 +1,44 @@
<html>
<head>
<title>config/limits.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>config/limits.hpp</b> header defines various library limits.
</div>
<h4>
Usage
</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/config/limits.hpp&gt;</b>
</div>
<h4>
Contents
</h4>
<ul>
<li><a href="../../ref/limit_dim.html">BOOST_PP_LIMIT_DIM</a></li>
<li><a href="../../ref/limit_for.html">BOOST_PP_LIMIT_FOR</a></li>
<li><a href="../../ref/limit_iteration.html">BOOST_PP_LIMIT_ITERATION</a></li>
<li><a href="../../ref/limit_iteration_dim.html">BOOST_PP_LIMIT_ITERATION_DIM</a></li>
<li><a href="../../ref/limit_mag.html">BOOST_PP_LIMIT_MAG</a></li>
<li><a href="../../ref/limit_repeat.html">BOOST_PP_LIMIT_REPEAT</a></li>
<li><a href="../../ref/limit_seq.html">BOOST_PP_LIMIT_SEQ</a></li>
<li><a href="../../ref/limit_slot_count.html">BOOST_PP_LIMIT_SLOT_COUNT</a></li>
<li><a href="../../ref/limit_slot_sig.html">BOOST_PP_LIMIT_SLOT_SIG</a></li>
<li><a href="../../ref/limit_tuple.html">BOOST_PP_LIMIT_TUPLE</a></li>
<li><a href="../../ref/limit_while.html">BOOST_PP_LIMIT_WHILE</a></li>
</ul>
<head>
<title>config/limits.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>config/limits.hpp</b> header defines various library limits.
</div>
<h4>
Usage
</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/config/limits.hpp&gt;</b>
</div>
<h4>
Contents
</h4>
<ul>
<li><a href="../../ref/limit_dim.html">BOOST_PP_LIMIT_DIM</a></li>
<li><a href="../../ref/limit_for.html">BOOST_PP_LIMIT_FOR</a></li>
<li><a href="../../ref/limit_iteration.html">BOOST_PP_LIMIT_ITERATION</a></li>
<li><a href="../../ref/limit_iteration_dim.html">BOOST_PP_LIMIT_ITERATION_DIM</a></li>
<li><a href="../../ref/limit_mag.html">BOOST_PP_LIMIT_MAG</a></li>
<li><a href="../../ref/limit_repeat.html">BOOST_PP_LIMIT_REPEAT</a></li>
<li><a href="../../ref/limit_seq.html">BOOST_PP_LIMIT_SEQ</a></li>
<li><a href="../../ref/limit_slot_count.html">BOOST_PP_LIMIT_SLOT_COUNT</a></li>
<li><a href="../../ref/limit_slot_sig.html">BOOST_PP_LIMIT_SLOT_SIG</a></li>
<li><a href="../../ref/limit_tuple.html">BOOST_PP_LIMIT_TUPLE</a></li>
<li><a href="../../ref/limit_while.html">BOOST_PP_LIMIT_WHILE</a></li>
<li><a href="../../ref/limit_variadic.html">BOOST_PP_LIMIT_VARIADIC</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
<br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</body>
</html>

View File

@ -0,0 +1,35 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=windows-1252">
<title>config/config.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>config/config.hpp</b>
header defines internal configuration macros as well as a macro
for determining whether the compiler's preprocessor conforms to
the standard. The file is automatically included whenever any
Boost PP macros are used.The end-user can manually include it
in order to use the BOOST_PP_IS_STANDARD macro, but normally
should never have to do so.</div>
<h4> Usage </h4>
<div class="code"> #include <b>&lt;boost/preprocessor/config/config.hpp&gt;</b>
</div>
<h4> Contents </h4>
<ul>
<li><a href="../../ref/is_standard.html">BOOST_PP_IS_STANDARD</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"><i><EFBFBD> Copyright Edward Diener
2011,2014,2020</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version
1.0. (See accompanying file <a
href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,10 +1,10 @@
<html>
<head>
<title>facilities.hpp</title>
<title>facilities.hpp</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
<div style="margin-left: 0px;">
The <b>facilities.hpp</b> includes the headers in the <i>facilities</i> folder.
</div>
<h4>Usage</h4>
@ -15,20 +15,21 @@
<ul>
<li><a href="facilities/apply.html">&lt;boost/preprocessor/facilities/apply.hpp&gt;</a></li>
<li><a href="facilities/empty.html">&lt;boost/preprocessor/facilities/empty.hpp&gt;</a></li>
<li><a href="facilities/check_empty.html">&lt;boost/preprocessor/facilities/check_empty.hpp&gt;</a> <a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
<li><a href="facilities/expand.html">&lt;boost/preprocessor/facilities/expand.hpp&gt;</a></li>
<li><a href="facilities/identity.html">&lt;boost/preprocessor/facilities/identity.hpp&gt;</a></li>
<li><a href="facilities/intercept.html">&lt;boost/preprocessor/facilities/intercept.hpp&gt;</a></li>
<li><a href="facilities/overload.html">&lt;boost/preprocessor/facilities/overload.hpp&gt;</a> <a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
<br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,29 @@
<html>
<head>
<title>facilities/check_empty.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>facilities/check_empty.hpp</b> header defines a variadic macro for the C++20 level that checks if its data is empty or not.
</div>
<h4>Usage</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/facilities/check_empty.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/check_empty.html">BOOST_PP_CHECK_EMPTY</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i><EFBFBD> Copyright Edward Diener 2019</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -5,7 +5,7 @@
</head>
<body>
<div style="margin-left: 0px;">
The <b>facilities/identity.hpp</b> header defines a utility macro to use with <b>BOOST_PP_IF</b> and <b>BOOST_PP_IIF</b>.
The <b>facilities/identity.hpp</b> header defines utility macros to use with <b>BOOST_PP_IF</b> and <b>BOOST_PP_IIF</b>.
</div>
<h4>Usage</h4>
<div class="code">
@ -14,11 +14,13 @@
<h4>Contents</h4>
<ul>
<li><a href="../../ref/identity.html">BOOST_PP_IDENTITY</a></li>
<li><a href="../../ref/identity_n.html">BOOST_PP_IDENTITY_N</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</br><i><EFBFBD> Copyright Edward Diener 2015</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See

View File

@ -0,0 +1,28 @@
<html>
<head>
<title>facilities/overload.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>facilities/overload.hpp</b> header defines variadic macros that overload non-variadic macros to accept different numbers of parameters.
</div>
<h4>Usage</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/facilities/overload.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/overload.html">BOOST_PP_OVERLOAD</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i><EFBFBD> Copyright Edward Diener 2011,2013</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,32 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="content-type" content="text/html;
charset=windows-1252">
<title>facilities/va_opt.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>facilities/va_opt.hpp</b>
header defines a variadic macro for the C++20 level that offers a
more flexible alternative to the __VA_OPT__ construct. </div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/facilities/va_opt.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/va_opt.html">BOOST_PP_VA_OPT</a> <a
href="../../topics/variadic_macros.html#VNotation"
target="_self">(v)</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2019</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version
1.0. (See accompanying file <a
href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,10 +1,10 @@
<html>
<head>
<title>list.hpp</title>
<title>list.hpp</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
<div style="margin-left: 0px;">
The <b>list.hpp</b> includes the headers in the <i>list</i> folder.
</div>
<h4>Usage</h4>
@ -28,19 +28,20 @@
<li><a href="list/rest_n.html">&lt;boost/preprocessor/list/rest_n.hpp&gt;</a></li>
<li><a href="list/reverse.html">&lt;boost/preprocessor/list/reverse.hpp&gt;</a></li>
<li><a href="list/size.html">&lt;boost/preprocessor/list/size.hpp&gt;</a></li>
<li><a href="list/to_array.html">&lt;boost/preprocessor/list/to_array.hpp&gt;</a></li>
<li><a href="list/to_seq.html">&lt;boost/preprocessor/list/to_seq.hpp&gt;</a></li>
<li><a href="list/to_tuple.html">&lt;boost/preprocessor/list/to_tuple.hpp&gt;</a></li>
<li><a href="list/transform.html">&lt;boost/preprocessor/list/transform.hpp&gt;</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
<br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,29 @@
<html>
<head>
<title>list/to_array.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>list/to_array.hpp</b> header defines a macro to convert a <i>list</i> to an <i>array</i>.
</div>
<h4>Usage</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/list/to_array.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/list_to_array.html">BOOST_PP_LIST_TO_ARRAY</a></li>
<li><a href="../../ref/list_to_array_d.html">BOOST_PP_LIST_TO_ARRAY_D</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i>© Copyright Edward Diener 2011</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,25 @@
<html><head>
<title>list/to_seq.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>list/to_seq.hpp</b> header defines a macro to convert a <i>list</i> to a <i>seq</i>.
</div>
<h4>Usage</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/list/to_seq.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/list_to_seq.html">BOOST_PP_LIST_TO_SEQ</a></li>
<li><a href="../../ref/list_to_seq.html">BOOST_PP_LIST_TO_SEQ_R</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i>© Copyright Edward Diener 2011</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body></html>

View File

@ -0,0 +1,26 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>punctuation/is_begin_parens.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>punctuation/is_begin_parens.hpp</b>
header defines a macro that determines if variadic data begins with a
parenthesis.</div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/punctuation/is_begin_parens.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/is_begin_parens.html">BOOST_PP_IS_BEGIN_PARENS</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2014</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,26 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>punctuation/remove_parens.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>punctuation/remove_parens.hpp</b>
header defines a macro that removes the beginning parenthesis from its
input if it exists.</div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/punctuation/remove_parens.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/remove_parens.html">BOOST_PP_REMOVE_PARENS</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2014</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,83 +1,86 @@
<html>
<head>
<title>seq.hpp</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>seq.hpp</b> includes the headers in the <i>seq</i> folder.
</div>
<h4>
Usage
</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/seq.hpp&gt;</b>
</div>
<h4>
Includes
</h4>
<ul>
<li>
<a href="seq/cat.html">&lt;boost/preprocessor/seq/cat.hpp&gt;</a></li>
<li>
<a href="seq/elem.html">&lt;boost/preprocessor/seq/elem.hpp&gt;</a></li>
<li>
<a href="seq/enum.html">&lt;boost/preprocessor/seq/enum.hpp&gt;</a></li>
<li>
<a href="seq/filter.html">&lt;boost/preprocessor/seq/filter.hpp&gt;</a></li>
<li>
<a href="seq/first_n.html">&lt;boost/preprocessor/seq/first_n.hpp&gt;</a></li>
<li>
<a href="seq/fold_left.html">&lt;boost/preprocessor/seq/fold_left.hpp&gt;</a></li>
<li>
<a href="seq/fold_right.html">&lt;boost/preprocessor/seq/fold_right.hpp&gt;</a></li>
<li>
<a href="seq/for_each.html">&lt;boost/preprocessor/seq/for_each.hpp&gt;</a></li>
<li>
<a href="seq/for_each_i.html">&lt;boost/preprocessor/seq/for_each_i.hpp&gt;</a></li>
<li>
<a href="seq/for_each_product.html">&lt;boost/preprocessor/seq/for_each_product.hpp&gt;</a></li>
<li>
<a href="seq/insert.html">&lt;boost/preprocessor/seq/insert.hpp&gt;</a></li>
<li>
<a href="seq/pop_back.html">&lt;boost/preprocessor/seq/pop_back.hpp&gt;</a></li>
<li>
<a href="seq/pop_front.html">&lt;boost/preprocessor/seq/pop_front.hpp&gt;</a></li>
<li>
<a href="seq/push_back.html">&lt;boost/preprocessor/seq/push_back.hpp&gt;</a></li>
<li>
<a href="seq/push_front.html">&lt;boost/preprocessor/seq/push_front.hpp&gt;</a></li>
<li>
<a href="seq/remove.html">&lt;boost/preprocessor/seq/remove.hpp&gt;</a></li>
<li>
<a href="seq/replace.html">&lt;boost/preprocessor/seq/replace.hpp&gt;</a></li>
<li>
<a href="seq/rest_n.html">&lt;boost/preprocessor/seq/rest_n.hpp&gt;</a></li>
<li>
<a href="seq/reverse.html">&lt;boost/preprocessor/seq/reverse.hpp&gt;</a></li>
<li>
<a href="seq/seq.html">&lt;boost/preprocessor/seq/seq.hpp&gt;</a></li>
<li>
<a href="seq/size.html">&lt;boost/preprocessor/seq/size.hpp&gt;</a></li>
<li>
<a href="seq/subseq.html">&lt;boost/preprocessor/seq/subseq.hpp&gt;</a></li>
<li>
<a href="seq/to_array.html">&lt;boost/preprocessor/seq/to_array.hpp&gt;</a></li>
<li>
<a href="seq/to_tuple.html">&lt;boost/preprocessor/seq/to_tuple.hpp&gt;</a></li>
<li>
<a href="seq/transform.html">&lt;boost/preprocessor/seq/transform.hpp&gt;</a></li>
</ul>
<hr size="1">
<head>
<title>seq.hpp</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
The <b>seq.hpp</b> includes the headers in the <i>seq</i> folder.
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
<h4>
Usage
</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/seq.hpp&gt;</b>
</div>
</body>
<h4>
Includes
</h4>
<ul>
<li>
<a href="seq/cat.html">&lt;boost/preprocessor/seq/cat.hpp&gt;</a></li>
<li>
<a href="seq/elem.html">&lt;boost/preprocessor/seq/elem.hpp&gt;</a></li>
<li>
<a href="seq/enum.html">&lt;boost/preprocessor/seq/enum.hpp&gt;</a></li>
<li>
<a href="seq/filter.html">&lt;boost/preprocessor/seq/filter.hpp&gt;</a></li>
<li>
<a href="seq/first_n.html">&lt;boost/preprocessor/seq/first_n.hpp&gt;</a></li>
<li>
<a href="seq/fold_left.html">&lt;boost/preprocessor/seq/fold_left.hpp&gt;</a></li>
<li>
<a href="seq/fold_right.html">&lt;boost/preprocessor/seq/fold_right.hpp&gt;</a></li>
<li>
<a href="seq/for_each.html">&lt;boost/preprocessor/seq/for_each.hpp&gt;</a></li>
<li>
<a href="seq/for_each_i.html">&lt;boost/preprocessor/seq/for_each_i.hpp&gt;</a></li>
<li>
<a href="seq/for_each_product.html">&lt;boost/preprocessor/seq/for_each_product.hpp&gt;</a></li>
<li>
<a href="seq/insert.html">&lt;boost/preprocessor/seq/insert.hpp&gt;</a></li>
<li>
<a href="seq/pop_back.html">&lt;boost/preprocessor/seq/pop_back.hpp&gt;</a></li>
<li>
<a href="seq/pop_front.html">&lt;boost/preprocessor/seq/pop_front.hpp&gt;</a></li>
<li>
<a href="seq/push_back.html">&lt;boost/preprocessor/seq/push_back.hpp&gt;</a></li>
<li>
<a href="seq/push_front.html">&lt;boost/preprocessor/seq/push_front.hpp&gt;</a></li>
<li>
<a href="seq/remove.html">&lt;boost/preprocessor/seq/remove.hpp&gt;</a></li>
<li>
<a href="seq/replace.html">&lt;boost/preprocessor/seq/replace.hpp&gt;</a></li>
<li>
<a href="seq/rest_n.html">&lt;boost/preprocessor/seq/rest_n.hpp&gt;</a></li>
<li>
<a href="seq/reverse.html">&lt;boost/preprocessor/seq/reverse.hpp&gt;</a></li>
<li>
<a href="seq/seq.html">&lt;boost/preprocessor/seq/seq.hpp&gt;</a></li>
<li>
<a href="seq/size.html">&lt;boost/preprocessor/seq/size.hpp&gt;</a></li>
<li>
<a href="seq/subseq.html">&lt;boost/preprocessor/seq/subseq.hpp&gt;</a></li>
<li>
<a href="seq/to_array.html">&lt;boost/preprocessor/seq/to_array.hpp&gt;</a></li>
<li>
<a href="seq/to_list.html">&lt;boost/preprocessor/seq/to_list.hpp&gt;</a></li>
<li>
<a href="seq/to_tuple.html">&lt;boost/preprocessor/seq/to_tuple.hpp&gt;</a></li>
<li>
<a href="seq/transform.html">&lt;boost/preprocessor/seq/transform.hpp&gt;</a></li>
<li>
<a href="seq/variadic_seq_to_seq.html">&lt;boost/preprocessor/seq/variadic_seq_to_seq.hpp&gt;</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
<br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,30 @@
<html><head>
<title>seq/to_list.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>seq/to_list.hpp</b> header defines a macro that converts a <i>seq</i> to
a <i>list</i>.
</div>
<h4>
Usage
</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/seq/to_list.hpp&gt;</b>
</div>
<h4>
Contents
</h4>
<ul>
<li>
<a href="../../ref/seq_to_list.html">BOOST_PP_SEQ_TO_LIST</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i><EFBFBD> Copyright Edward Diener 2011</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body></html>

View File

@ -0,0 +1,34 @@
<html>
<head>
<title>seq/variadic_seq_to_seq.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>seq/variadic_seq_to_seq.hpp</b> header defines a macro that converts a <i>variadic seq</i> into a <i>seq</i>.
</div>
<h4>
Usage
</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/seq/variadic_seq_to_seq.hpp&gt;</b>
</div>
<h4>
Contents
</h4>
<ul>
<li>
<a href="../../ref/variadic_seq_to_seq.html">BOOST_PP_VARIADIC_SEQ_TO_SEQ</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i>© Copyright Paul Mensonides 2012</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,34 +1,59 @@
<html>
<head>
<title>tuple.hpp</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>tuple.hpp</b> includes the headers in the <i>tuple</i> folder.
</div>
<h4>Usage</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/tuple.hpp&gt;</b>
</div>
<h4>Includes</h4>
<ul>
<li><a href="tuple/elem.html">&lt;boost/preprocessor/tuple/elem.hpp&gt;</a></li>
<li><a href="tuple/eat.html">&lt;boost/preprocessor/tuple/eat.hpp&gt;</a></li>
<li><a href="tuple/rem.html">&lt;boost/preprocessor/tuple/rem.hpp&gt;</a></li>
<li><a href="tuple/reverse.html">&lt;boost/preprocessor/tuple/reverse.hpp&gt;</a></li>
<li><a href="tuple/to_list.html">&lt;boost/preprocessor/tuple/to_list.hpp&gt;</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>tuple.hpp</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>tuple.hpp</b> includes the headers
in the <i>tuple</i> folder. </div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/tuple.hpp&gt;</b> </div>
<h4>Includes</h4>
<ul>
<li><a href="tuple/eat.html">&lt;boost/preprocessor/tuple/eat.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
<li><a href="tuple/elem.html">&lt;boost/preprocessor/tuple/elem.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
<li><a href="tuple/enum.html">&lt;boost/preprocessor/tuple/enum.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
<li><a href="tuple/insert.html">&lt;boost/preprocessor/tuple/insert.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="tuple/pop_back.html">&lt;boost/preprocessor/tuple/pop_back.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="tuple/pop_front.html">&lt;boost/preprocessor/tuple/pop_front.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="tuple/push_back.html">&lt;boost/preprocessor/tuple/push_back.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="tuple/push_front.html">&lt;boost/preprocessor/tuple/push_front.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="tuple/rem.html">&lt;boost/preprocessor/tuple/rem.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
<li><a href="tuple/remove.html">&lt;boost/preprocessor/tuple/remove.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="tuple/replace.html">&lt;boost/preprocessor/tuple/replace.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="tuple/reverse.html">&lt;boost/preprocessor/tuple/reverse.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
<li><a href="tuple/size.html">&lt;boost/preprocessor/tuple/size.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
<li><a href="tuple/to_array.html">&lt;boost/preprocessor/tuple/to_array.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
<li><a href="tuple/to_list.html">&lt;boost/preprocessor/tuple/to_list.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
<li><a href="tuple/to_seq.html">&lt;boost/preprocessor/tuple/to_seq.hpp&gt;</a>
<a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a href="http://www.housemarque.com"
target="_top">Housemarque Oy</a> 2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002<br>
</i><i><EFBFBD> Copyright Edward Diener 2013</i><br>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,10 +1,6 @@
<html>
<head>
<title>tuple/eat.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
<html><head><title>tuple/eat.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>tuple/eat.hpp</b> header defines a macro eats a <i>tuple</i>.
</div>
<h4>Usage</h4>
@ -13,18 +9,17 @@
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_eat.html">BOOST_PP_TUPLE_EAT</a></li>
<li><a href="../../ref/tuple_eat.html">BOOST_PP_TUPLE_EAT</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
<br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>
</body></html>

View File

@ -1,10 +1,6 @@
<html>
<head>
<title>tuple/elem.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
<html><head><title>tuple/elem.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>tuple/elem.hpp</b> header defines a macro to extract elements from a <i>tuple</i>.
</div>
<h4>Usage</h4>
@ -13,18 +9,17 @@
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_elem.html">BOOST_PP_TUPLE_ELEM</a></li>
<li><a href="../../ref/tuple_elem.html">BOOST_PP_TUPLE_ELEM</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
<br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>
</body></html>

View File

@ -0,0 +1,25 @@
<html><head>
<title>tuple/enum.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>tuple/enum.hpp</b> header defines a macro to convert a <i>tuple</i> to its comma-separated elements.
</div>
<h4>Usage</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/tuple/enum.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_enum.html">BOOST_PP_TUPLE_ENUM</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i><EFBFBD> Copyright Edward Diener 2011,2013</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body></html>

View File

@ -0,0 +1,27 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>tuple/insert.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>tuple/insert.hpp</b> header defines
macros to insert an element into an <i>tuple</i>.</div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/tuple/insert.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_insert.html">BOOST_PP_TUPLE_INSERT</a> <a href="../../topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="../../ref/tuple_insert_d.html">BOOST_PP_TUPLE_INSERT_D</a> <a
href="../../topics/variadic_macros.html#VNotation">(v)</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2013</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,28 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>tuple/pop_back.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>tuple/pop_back.hpp</b> header
defines macros to pop an element from the end of an <i>tuple</i>.</div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/tuple/pop_back.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_pop_back.html">BOOST_PP_TUPLE_POP_BACK</a> <a
href="../../topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="../../ref/tuple_pop_back_z.html">BOOST_PP_TUPLE_POP_BACK_Z</a>
<a href="../../topics/variadic_macros.html#VNotation">(v)</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2013</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,28 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>tuple/pop_front.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>tuple/pop_front.hpp</b> header
defines macros to pop an element from the beginning of an <i>tuple</i>.</div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/tuple/pop_front.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_pop_front.html">BOOST_PP_TUPLE_POP_FRONT</a>
<a href="../../topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="../../ref/tuple_pop_front_z.html">BOOST_PP_TUPLE_POP_FRONT_Z</a>
<a href="../../topics/variadic_macros.html#VNotation">(v)</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2013</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,26 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>tuple/push_back.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>tuple/push_back.hpp</b> header
defines a macro to append an element to the end of an <i>tuple</i>.</div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/tuple/push_back.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_push_back.html">BOOST_PP_TUPLE_PUSH_BACK</a>
<a href="../../topics/variadic_macros.html#VNotation">(v)</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2013</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,26 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>tuple/push_front.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>tuple/push_front.hpp</b> header
defines a macro to append an element to the beginning of an <i>tuple</i>.</div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/tuple/push_front.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_push_front.html">BOOST_PP_TUPLE_PUSH_FRONT</a>
<a href="../../topics/variadic_macros.html#VNotation">(v)</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2013</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,10 +1,6 @@
<html>
<head>
<title>tuple/rem.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
<html><head><title>tuple/rem.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>tuple/rem.hpp</b> header defines a macro that removes the parentheses from a <i>tuple</i>.
</div>
<h4>Usage</h4>
@ -13,19 +9,19 @@
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_rem.html">BOOST_PP_TUPLE_REM</a></li>
<li><a href="../../ref/tuple_rem_ctor.html">BOOST_PP_TUPLE_REM_CTOR</a></li>
<li><a href="../../ref/tuple_rem.html">BOOST_PP_TUPLE_REM</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
<li><a href="../../ref/tuple_rem_ctor.html">BOOST_PP_TUPLE_REM_CTOR</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
<br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>
</body></html>

View File

@ -0,0 +1,27 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>tuple/remove.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>tuple/remove.hpp</b> header defines
macros to remove an element from an <i>array</i>. </div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/tuple/remove.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_remove.html">BOOST_PP_TUPLE_REMOVE</a> <a href="../../topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="../../ref/tuple_remove_d.html">BOOST_PP_TUPLE_REMOVE_D</a> <a
href="../../topics/variadic_macros.html#VNotation">(v)</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2013</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,28 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>tuple/replace.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>tuple/replace.hpp</b> header
defines macros to replace an element in an <i>array</i>.</div>
<h4>Usage</h4>
<div class="code"> #include <b>&lt;boost/preprocessor/tuple/replace.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_replace.html">BOOST_PP_TUPLE_REPLACE</a> <a
href="../../topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="../../ref/tuple_replace_d.html">BOOST_PP_TUPLE_REPLACE_D</a>
<a href="../../topics/variadic_macros.html#VNotation">(v)</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2013</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,10 +1,6 @@
<html>
<head>
<title>tuple/reverse.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
<html><head><title>tuple/reverse.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>tuple/reverse.hpp</b> header defines a macro that reverses a <i>tuple</i>.
</div>
<h4>Usage</h4>
@ -13,18 +9,17 @@
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_reverse.html">BOOST_PP_TUPLE_REVERSE</a></li>
<li><a href="../../ref/tuple_reverse.html">BOOST_PP_TUPLE_REVERSE</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
<br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>
</body></html>

View File

@ -0,0 +1,25 @@
<html><head>
<title>tuple/size.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>tuple/size.hpp</b> header defines a variadic macro that gives the number of elements in the <i>tuple</i>.
</div>
<h4>Usage</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/tuple/size.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_size.html">BOOST_PP_TUPLE_SIZE</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i><EFBFBD> Copyright Edward Diener 2011,2013</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body></html>

View File

@ -0,0 +1,25 @@
<html><head>
<title>tuple/to_array.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>tuple/to_array.hpp</b> header defines a macro that converts a <i>tuple</i> to an <i>array</i>.
</div>
<h4>Usage</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/tuple/to_array.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_to_array.html">BOOST_PP_TUPLE_TO_ARRAY</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i><EFBFBD> Copyright Edward Diener 2011,2013</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body></html>

View File

@ -1,10 +1,6 @@
<html>
<head>
<title>tuple/to_list.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
<html><head><title>tuple/to_list.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>tuple/to_list.hpp</b> header defines a macro that converts a <i>tuple</i> to a <i>list</i>.
</div>
<h4>Usage</h4>
@ -13,18 +9,17 @@
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/tuple_to_list.html">BOOST_PP_TUPLE_TO_LIST</a></li>
<li><a href="../../ref/tuple_to_list.html">BOOST_PP_TUPLE_TO_LIST</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><sup><br>
</sup></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
<br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>
</body></html>

View File

@ -1,10 +1,6 @@
<html>
<head>
<title>tuple/to_seq.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
<html><head><title>tuple/to_seq.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>tuple/to_seq.hpp</b> header defines a macro that converts a <i>tuple</i>
to a <i>seq</i>.
</div>
@ -19,18 +15,17 @@
</h4>
<ul>
<li>
<a href="../../ref/tuple_to_seq.html">BOOST_PP_TUPLE_TO_SEQ</a></li>
<a href="../../ref/tuple_to_seq.html">BOOST_PP_TUPLE_TO_SEQ</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
<br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>
</body></html>

34
doc/headers/variadic.html Normal file
View File

@ -0,0 +1,34 @@
<html>
<head>
<title>variadic.hpp</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>variadic.hpp</b> includes the headers in the <i>variadic</i> folder.
</div>
<h4>Usage</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/variadic.hpp&gt;</b>
</div>
<h4>Includes</h4>
<ul>
<li><a href="variadic/elem.html">&lt;boost/preprocessor/variadic/elem.hpp&gt;</a> <a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
<li><a href="variadic/has_opt.html">&lt;boost/preprocessor/variadic/has_opt.hpp&gt;</a> </li>
<li><a href="variadic/size.html">&lt;boost/preprocessor/variadic/size.hpp&gt;</a> <a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
<li><a href="variadic/to_array.html">&lt;boost/preprocessor/variadic/to_array.hpp&gt;</a> <a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
<li><a href="variadic/to_list.html">&lt;boost/preprocessor/variadic/to_list.hpp&gt;</a> <a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
<li><a href="variadic/to_seq.html">&lt;boost/preprocessor/variadic/to_seq.hpp&gt;</a> <a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
<li><a href="variadic/to_tuple.html">&lt;boost/preprocessor/variadic/to_tuple.hpp&gt;</a> <a href="../topics/variadic_macros.html#VNotation" target="_self">(v)</a></li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i><EFBFBD> Copyright Edward Diener 2011,2013,2019</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,29 @@
<html>
<head>
<title>variadic/elem.hpp
</title>
<link rel="stylesheet" type="text/css" href="../../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>variadic/elem.hpp</b> header defines a variadic macro to extract an element from <i>variadic data</i>.
</div>
<h4>Usage</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/variadic/elem.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/variadic_elem.html">BOOST_PP_VARIADIC_ELEM</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i><EFBFBD> Copyright Edward Diener 2011,2013</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body></html>

View File

@ -0,0 +1,25 @@
<html><head>
<title>variadic/has_opt.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>variadic/has_opt.hpp</b> header defines a macro that determines whether or not the __VA_OPT__ construct is supported.
</div>
<h4>Usage</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/variadic/has_opt.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/variadic_has_opt.html">BOOST_PP_VARIADIC_HAS_OPT</a> <br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i><EFBFBD> Copyright Edward Diener 2019</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body></html>

View File

@ -0,0 +1,25 @@
<html><head>
<title>variadic/size.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>variadic/size.hpp</b> header defines a variadic macro that gives the number of comma-separated elements in the <i>variadic data</i>.
</div>
<h4>Usage</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/variadic/size.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/variadic_size.html">BOOST_PP_VARIADIC_SIZE</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i><EFBFBD> Copyright Edward Diener 2011,2013</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body></html>

View File

@ -0,0 +1,25 @@
<html><head>
<title>variadic/to_array.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>variadic/to_array.hpp</b> header defines a variadic macro that converts <i>variadic data</i> to an <i>array</i>.
</div>
<h4>Usage</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/variadic/to_array.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/variadic_to_array.html">BOOST_PP_VARIADIC_TO_ARRAY</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i><EFBFBD> Copyright Edward Diener 2011,2013</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body></html>

View File

@ -0,0 +1,25 @@
<html><head>
<title>variadic/to_list.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>variadic/to_list.hpp</b> header defines a variadic macro that converts <i>variadic data </i>to a <i>list</i>.
</div>
<h4>Usage</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/variadic/to_list.hpp&gt;</b>
</div>
<h4>Contents</h4>
<ul>
<li><a href="../../ref/variadic_to_list.html">BOOST_PP_VARIADIC_TO_LIST</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i><EFBFBD> Copyright Edward Diener 2011,2013</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body></html>

View File

@ -0,0 +1,30 @@
<html><head>
<title>variadic/to_seq.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>variadic/to_seq.hpp</b> header defines a variadic macro that converts <i>variadic data </i>to a <i>seq</i>.
</div>
<h4>
Usage
</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/variadic/to_seq.hpp&gt;</b>
</div>
<h4>
Contents
</h4>
<ul>
<li>
<a href="../../ref/variadic_to_seq.html">BOOST_PP_VARIADIC_TO_SEQ</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i><EFBFBD> Copyright Edward Diener 2011,2013</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body></html>

View File

@ -0,0 +1,31 @@
<html><head>
<title>variadic/to_tuple.hpp</title>
<link rel="stylesheet" type="text/css" href="../../styles.css"></head><body>
<div style="margin-left: 0px;">
The <b>variadic/to_tuple.hpp</b> header defines a variadic macro that converts <i>variadic data</i>
to a <i>tuple</i>.
</div>
<h4>
Usage
</h4>
<div class="code">
#include <b>&lt;boost/preprocessor/variadic/to_tuple.hpp&gt;</b>
</div>
<h4>
Contents
</h4>
<ul>
<li>
<a href="../../ref/variadic_to_tuple.html">BOOST_PP_VARIADIC_TO_TUPLE</a> <a href="../../topics/variadic_macros.html#VNotation" target="_self">(v)</a><br>
</li>
</ul>
<hr size="1">
<div style="margin-left: 0px;">
<i></i><i><EFBFBD> Copyright Edward Diener 2011,2013</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body></html>

View File

@ -1,286 +1,323 @@
<html>
<head>
<title>ref.html</title>
<link rel="stylesheet" type="text/css" href="styles.css">
<base target="desc">
</head>
<body>
<h4>
Reference <small><a href="contents.html" target="index">[back]</a></small>
</h4>
<ul>
<!-- A -->
<li><a href="ref/add.html">ADD</a></li>
<li><a href="ref/add_d.html">ADD_D</a></li>
<li><a href="ref/and.html">AND</a></li>
<li><a href="ref/apply.html">APPLY</a></li>
<li><a href="ref/array_data.html">ARRAY_DATA</a></li>
<li><a href="ref/array_elem.html">ARRAY_ELEM</a></li>
<li><a href="ref/array_insert.html">ARRAY_INSERT</a></li>
<li><a href="ref/array_insert_d.html">ARRAY_INSERT_D</a></li>
<li><a href="ref/array_pop_back.html">ARRAY_POP_BACK</a></li>
<li><a href="ref/array_pop_back_z.html">ARRAY_POP_BACK_Z</a></li>
<li><a href="ref/array_pop_front.html">ARRAY_POP_FRONT</a></li>
<li><a href="ref/array_pop_front_z.html">ARRAY_POP_FRONT_Z</a></li>
<li><a href="ref/array_push_back.html">ARRAY_PUSH_BACK</a></li>
<li><a href="ref/array_push_front.html">ARRAY_PUSH_FRONT</a></li>
<li><a href="ref/array_remove.html">ARRAY_REMOVE</a></li>
<li><a href="ref/array_remove_d.html">ARRAY_REMOVE_D</a></li>
<li><a href="ref/array_replace.html">ARRAY_REPLACE</a></li>
<li><a href="ref/array_replace_d.html">ARRAY_REPLACE_D</a></li>
<li><a href="ref/array_reverse.html">ARRAY_REVERSE</a></li>
<li><a href="ref/array_size.html">ARRAY_SIZE</a></li>
<li><a href="ref/assert.html">ASSERT</a></li>
<li><a href="ref/assert_msg.html">ASSERT_MSG</a></li>
<li><a href="ref/assign_slot.html">ASSIGN_SLOT</a></li>
<!-- B -->
<li><a href="ref/bitand.html">BITAND</a></li>
<li><a href="ref/bitnor.html">BITNOR</a></li>
<li><a href="ref/bitor.html">BITOR</a></li>
<li><a href="ref/bitxor.html">BITXOR</a></li>
<li><a href="ref/bool.html">BOOL</a></li>
<!-- C -->
<li><a href="ref/cat.html">CAT</a></li>
<li><a href="ref/comma.html">COMMA</a></li>
<li><a href="ref/comma_if.html">COMMA_IF</a></li>
<li><a href="ref/compl.html">COMPL</a></li>
<li><a href="ref/config_extended_line_info.html">CONFIG_EXTENDED_LINE_INFO</a></li>
<li><a href="ref/counter.html">COUNTER</a></li>
<!-- D -->
<li><a href="ref/dec.html">DEC</a></li>
<li><a href="ref/deduce_d.html">DEDUCE_D</a></li>
<li><a href="ref/deduce_r.html">DEDUCE_R</a></li>
<li><a href="ref/deduce_z.html">DEDUCE_Z</a></li>
<li><a href="ref/div.html">DIV</a></li>
<li><a href="ref/div_d.html">DIV_D</a></li>
<!-- E -->
<li><a href="ref/empty.html">EMPTY</a></li>
<li><a href="ref/enum.html">ENUM</a></li>
<li><a href="ref/enum_binary_params.html">ENUM_BINARY_PARAMS</a></li>
<li><a href="ref/enum_binary_params_z.html">ENUM_BINARY_PARAMS_Z</a></li>
<li><a href="ref/enum_params.html">ENUM_PARAMS</a></li>
<li><a href="ref/enum_params_with_a_default.html">ENUM_PARAMS_WITH_A_DEFAULT*</a></li>
<li><a href="ref/enum_params_with_defaults.html">ENUM_PARAMS_WITH_DEFAULTS*</a></li>
<li><a href="ref/enum_params_z.html">ENUM_PARAMS_Z</a></li>
<li><a href="ref/enum_shifted.html">ENUM_SHIFTED</a></li>
<li><a href="ref/esbp.html">ENUM_SHIFTED_BINARY_PARAMS</a></li>
<li><a href="ref/esbpz.html">ENUM_SHIFTED_BINARY_PARAMS_Z</a></li>
<li><a href="ref/enum_shifted_params.html">ENUM_SHIFTED_PARAMS</a></li>
<li><a href="ref/enum_shifted_params_z.html">ENUM_SHIFTED_PARAMS_Z</a></li>
<li><a href="ref/enum_shifted_z.html">ENUM_SHIFTED_<i>z</i></a></li>
<li><a href="ref/enum_trailing.html">ENUM_TRAILING</a></li>
<li><a href="ref/etbp.html">ENUM_TRAILING_BINARY_PARAMS</a></li>
<li><a href="ref/etbpz.html">ENUM_TRAILING_BINARY_PARAMS_Z</a></li>
<li><a href="ref/enum_trailing_params.html">ENUM_TRAILING_PARAMS</a></li>
<li><a href="ref/enum_trailing_params_z.html">ENUM_TRAILING_PARAMS_Z</a></li>
<li><a href="ref/enum_trailing_z.html">ENUM_TRAILING_<i>z</i></a></li>
<li><a href="ref/enum_z.html">ENUM_<i>z</i></a></li>
<li><a href="ref/equal.html">EQUAL</a></li>
<li><a href="ref/equal_d.html">EQUAL_D*</a></li>
<li><a href="ref/expand.html">EXPAND</a></li>
<li><a href="ref/expr_if.html">EXPR_IF</a></li>
<li><a href="ref/expr_iif.html">EXPR_IIF</a></li>
<!-- F -->
<li><a href="ref/filename_x.html">FILENAME_<i>x</i></a></li>
<li><a href="ref/for.html">FOR</a></li>
<li><a href="ref/for_r.html">FOR_<i>r</i></a></li>
<li><a href="ref/frame_finish.html">FRAME_FINISH</a></li>
<li><a href="ref/frame_flags.html">FRAME_FLAGS</a></li>
<li><a href="ref/frame_iteration.html">FRAME_ITERATION</a></li>
<li><a href="ref/frame_start.html">FRAME_START</a></li>
<!-- G -->
<li><a href="ref/greater.html">GREATER</a></li>
<li><a href="ref/greater_d.html">GREATER_D</a></li>
<li><a href="ref/greater_equal.html">GREATER_EQUAL</a></li>
<li><a href="ref/greater_equal_d.html">GREATER_EQUAL_D</a></li>
<!-- I -->
<li><a href="ref/identity.html">IDENTITY</a></li>
<li><a href="ref/if.html">IF</a></li>
<li><a href="ref/iif.html">IIF</a></li>
<li><a href="ref/inc.html">INC</a></li>
<li><a href="ref/include_self.html">INCLUDE_SELF</a></li>
<li><a href="ref/indirect_self.html">INDIRECT_SELF</a></li>
<li><a href="ref/intercept.html">INTERCEPT</a></li>
<li><a href="ref/is_iterating.html">IS_ITERATING</a></li>
<li><a href="ref/is_selfish.html">IS_SELFISH</a></li>
<li><a href="ref/iterate.html">ITERATE</a></li>
<li><a href="ref/iteration.html">ITERATION</a></li>
<li><a href="ref/iteration_depth.html">ITERATION_DEPTH</a></li>
<li><a href="ref/iteration_finish.html">ITERATION_FINISH</a></li>
<li><a href="ref/iteration_flags.html">ITERATION_FLAGS</a></li>
<li><a href="ref/iteration_limits.html">ITERATION_LIMITS</a></li>
<li><a href="ref/iteration_params_x.html">ITERATION_PARAMS_<i>x</i></a></li>
<li><a href="ref/iteration_start.html">ITERATION_START</a></li>
<!-- L -->
<li><a href="ref/less.html">LESS</a></li>
<li><a href="ref/less_d.html">LESS_D</a></li>
<li><a href="ref/less_equal.html">LESS_EQUAL</a></li>
<li><a href="ref/less_equal_d.html">LESS_EQUAL_D</a></li>
<li><a href="ref/limit_dim.html">LIMIT_DIM</a></li>
<li><a href="ref/limit_for.html">LIMIT_FOR</a></li>
<li><a href="ref/limit_iteration.html">LIMIT_ITERATION</a></li>
<li><a href="ref/limit_iteration_dim.html">LIMIT_ITERATION_DIM</a></li>
<li><a href="ref/limit_mag.html">LIMIT_MAG</a></li>
<li><a href="ref/limit_repeat.html">LIMIT_REPEAT</a></li>
<li><a href="ref/limit_seq.html">LIMIT_SEQ</a></li>
<li><a href="ref/limit_slot_count.html">LIMIT_SLOT_COUNT</a></li>
<li><a href="ref/limit_slot_sig.html">LIMIT_SLOT_SIG</a></li>
<li><a href="ref/limit_tuple.html">LIMIT_TUPLE</a></li>
<li><a href="ref/limit_while.html">LIMIT_WHILE</a></li>
<li><a href="ref/line.html">LINE</a></li>
<li><a href="ref/list_append.html">LIST_APPEND</a></li>
<li><a href="ref/list_append_d.html">LIST_APPEND_D</a></li>
<li><a href="ref/list_at.html">LIST_AT</a></li>
<li><a href="ref/list_at_d.html">LIST_AT_D</a></li>
<li><a href="ref/list_cat.html">LIST_CAT</a></li>
<li><a href="ref/list_cat_d.html">LIST_CAT_D</a></li>
<li><a href="ref/list_cons.html">LIST_CONS*</a></li>
<li><a href="ref/list_enum.html">LIST_ENUM</a></li>
<li><a href="ref/list_enum_r.html">LIST_ENUM_R</a></li>
<li><a href="ref/list_filter.html">LIST_FILTER</a></li>
<li><a href="ref/list_filter_d.html">LIST_FILTER_D</a></li>
<li><a href="ref/list_first.html">LIST_FIRST</a></li>
<li><a href="ref/list_first_n.html">LIST_FIRST_N</a></li>
<li><a href="ref/list_first_n_d.html">LIST_FIRST_N_D</a></li>
<li><a href="ref/list_fold_left.html">LIST_FOLD_LEFT</a></li>
<li><a href="ref/list_fold_left_2nd.html">LIST_FOLD_LEFT_2ND*</a></li>
<li><a href="ref/list_fold_left_2nd_d.html">LIST_FOLD_LEFT_2ND_D*</a></li>
<li><a href="ref/list_fold_left_d.html">LIST_FOLD_LEFT_<i>d</i></a></li>
<li><a href="ref/list_fold_left_d_old.html">LIST_FOLD_LEFT_D*</a></li>
<li><a href="ref/list_fold_right.html">LIST_FOLD_RIGHT</a></li>
<li><a href="ref/list_fold_right_2nd.html">LIST_FOLD_RIGHT_2ND*</a></li>
<li><a href="ref/list_fold_right_2nd_d.html">LIST_FOLD_RIGHT_2ND_D*</a></li>
<li><a href="ref/list_fold_right_d.html">LIST_FOLD_RIGHT_<i>d</i></a></li>
<li><a href="ref/list_fold_right_d_old.html">LIST_FOLD_RIGHT_D*</a></li>
<li><a href="ref/list_for_each.html">LIST_FOR_EACH</a></li>
<li><a href="ref/list_for_each_i.html">LIST_FOR_EACH_I</a></li>
<li><a href="ref/list_for_each_i_r.html">LIST_FOR_EACH_I_R</a></li>
<li><a href="ref/list_for_each_product.html">LIST_FOR_EACH_PRODUCT</a></li>
<li><a href="ref/list_for_each_product_r.html">LIST_FOR_EACH_PRODUCT_R</a></li>
<li><a href="ref/list_for_each_r.html">LIST_FOR_EACH_R</a></li>
<li><a href="ref/list_is_cons.html">LIST_IS_CONS</a></li>
<li><a href="ref/list_is_nil.html">LIST_IS_NIL</a></li>
<li><a href="ref/list_nil.html">LIST_NIL*</a></li>
<li><a href="ref/list_rest.html">LIST_REST</a></li>
<li><a href="ref/list_rest_n.html">LIST_REST_N</a></li>
<li><a href="ref/list_rest_n_d.html">LIST_REST_N_D</a></li>
<li><a href="ref/list_reverse.html">LIST_REVERSE</a></li>
<li><a href="ref/list_reverse_d.html">LIST_REVERSE_D</a></li>
<li><a href="ref/list_size.html">LIST_SIZE</a></li>
<li><a href="ref/list_size_d.html">LIST_SIZE_D</a></li>
<li><a href="ref/list_to_tuple.html">LIST_TO_TUPLE</a></li>
<li><a href="ref/list_to_tuple_r.html">LIST_TO_TUPLE_R</a></li>
<li><a href="ref/list_transform.html">LIST_TRANSFORM</a></li>
<li><a href="ref/list_transform_d.html">LIST_TRANSFORM_D</a></li>
<li><a href="ref/local_iterate.html">LOCAL_ITERATE</a></li>
<li><a href="ref/local_limits.html">LOCAL_LIMITS</a></li>
<li><a href="ref/local_macro.html">LOCAL_MACRO</a></li>
<li><a href="ref/lparen.html">LPAREN</a></li>
<li><a href="ref/lparen_if.html">LPAREN_IF</a></li>
<!-- M -->
<li><a href="ref/max.html">MAX</a></li>
<li><a href="ref/max_d.html">MAX_D</a></li>
<li><a href="ref/min.html">MIN</a></li>
<li><a href="ref/min_d.html">MIN_D</a></li>
<li><a href="ref/mod.html">MOD</a></li>
<li><a href="ref/mod_d.html">MOD_D</a></li>
<li><a href="ref/mul.html">MUL</a></li>
<li><a href="ref/mul_d.html">MUL_D</a></li>
<!-- N -->
<li><a href="ref/nil.html">NIL</a></li>
<li><a href="ref/nor.html">NOR</a></li>
<li><a href="ref/not.html">NOT</a></li>
<li><a href="ref/not_equal.html">NOT_EQUAL</a></li>
<li><a href="ref/not_equal_d.html">NOT_EQUAL_D*</a></li>
<!-- O -->
<li><a href="ref/or.html">OR</a></li>
<!-- R -->
<li><a href="ref/relative_finish.html">RELATIVE_FINISH</a></li>
<li><a href="ref/relative_flags.html">RELATIVE_FLAGS</a></li>
<li><a href="ref/relative_iteration.html">RELATIVE_ITERATION</a></li>
<li><a href="ref/relative_start.html">RELATIVE_START</a></li>
<li><a href="ref/repeat.html">REPEAT</a></li>
<li><a href="ref/repeat_1st.html">REPEAT_1ST*</a></li>
<li><a href="ref/repeat_2nd.html">REPEAT_2ND*</a></li>
<li><a href="ref/repeat_3rd.html">REPEAT_3RD*</a></li>
<li><a href="ref/repeat_from_to.html">REPEAT_FROM_TO</a></li>
<li><a href="ref/repeat_from_to_1st.html">REPEAT_FROM_TO_1ST*</a></li>
<li><a href="ref/repeat_from_to_2nd.html">REPEAT_FROM_TO_2ND*</a></li>
<li><a href="ref/repeat_from_to_3rd.html">REPEAT_FROM_TO_3RD*</a></li>
<li><a href="ref/repeat_from_to_d.html">REPEAT_FROM_TO_D</a></li>
<li><a href="ref/repeat_from_to_d_z.html">REPEAT_FROM_TO_D_<i>z</i></a></li>
<li><a href="ref/repeat_from_to_z.html">REPEAT_FROM_TO_<i>z</i></a></li>
<li><a href="ref/repeat_z.html">REPEAT_<i>z</i></a></li>
<li><a href="ref/rparen.html">RPAREN</a></li>
<li><a href="ref/rparen_if.html">RPAREN_IF</a></li>
<!-- S -->
<li><a href="ref/seq_cat.html">SEQ_CAT</a></li>
<li><a href="ref/seq_cat_s.html">SEQ_CAT_S</a></li>
<li><a href="ref/seq_elem.html">SEQ_ELEM</a></li>
<li><a href="ref/seq_enum.html">SEQ_ENUM</a></li>
<li><a href="ref/seq_filter.html">SEQ_FILTER</a></li>
<li><a href="ref/seq_filter_s.html">SEQ_FILTER_S</a></li>
<li><a href="ref/seq_first_n.html">SEQ_FIRST_N</a></li>
<li><a href="ref/seq_fold_left.html">SEQ_FOLD_LEFT</a></li>
<li><a href="ref/seq_fold_left_s.html">SEQ_FOLD_LEFT_<i>s</i></a></li>
<li><a href="ref/seq_fold_right.html">SEQ_FOLD_RIGHT</a></li>
<li><a href="ref/seq_fold_right_s.html">SEQ_FOLD_RIGHT_<i>s</i></a></li>
<li><a href="ref/seq_for_each.html">SEQ_FOR_EACH</a></li>
<li><a href="ref/seq_for_each_i.html">SEQ_FOR_EACH_I</a></li>
<li><a href="ref/seq_for_each_i_r.html">SEQ_FOR_EACH_I_R</a></li>
<li><a href="ref/seq_for_each_product.html">SEQ_FOR_EACH_PRODUCT</a></li>
<li><a href="ref/seq_for_each_product_r.html">SEQ_FOR_EACH_PRODUCT_R</a></li>
<li><a href="ref/seq_for_each_r.html">SEQ_FOR_EACH_R</a></li>
<li><a href="ref/seq_head.html">SEQ_HEAD</a></li>
<li><a href="ref/seq_insert.html">SEQ_INSERT</a></li>
<li><a href="ref/seq_nil.html">SEQ_NIL</a></li>
<li><a href="ref/seq_pop_back.html">SEQ_POP_BACK</a></li>
<li><a href="ref/seq_pop_front.html">SEQ_POP_FRONT</a></li>
<li><a href="ref/seq_push_back.html">SEQ_PUSH_BACK</a></li>
<li><a href="ref/seq_push_front.html">SEQ_PUSH_FRONT</a></li>
<li><a href="ref/seq_remove.html">SEQ_REMOVE</a></li>
<li><a href="ref/seq_replace.html">SEQ_REPLACE</a></li>
<li><a href="ref/seq_rest_n.html">SEQ_REST_N</a></li>
<li><a href="ref/seq_reverse.html">SEQ_REVERSE</a></li>
<li><a href="ref/seq_reverse_s.html">SEQ_REVERSE_S</a></li>
<li><a href="ref/seq_size.html">SEQ_SIZE</a></li>
<li><a href="ref/seq_subseq.html">SEQ_SUBSEQ</a></li>
<li><a href="ref/seq_tail.html">SEQ_TAIL</a></li>
<li><a href="ref/seq_to_array.html">SEQ_TO_ARRAY</a></li>
<li><a href="ref/seq_to_tuple.html">SEQ_TO_TUPLE</a></li>
<li><a href="ref/seq_transform.html">SEQ_TRANSFORM</a></li>
<li><a href="ref/seq_transform_s.html">SEQ_TRANSFORM_S</a></li>
<li><a href="ref/slot.html">SLOT</a></li>
<li><a href="ref/stringize.html">STRINGIZE</a></li>
<li><a href="ref/sub.html">SUB</a></li>
<li><a href="ref/sub_d.html">SUB_D</a></li>
<!-- T -->
<li><a href="ref/tuple_eat.html">TUPLE_EAT</a></li>
<li><a href="ref/tuple_elem.html">TUPLE_ELEM</a></li>
<li><a href="ref/tuple_rem.html">TUPLE_REM</a></li>
<li><a href="ref/tuple_rem_ctor.html">TUPLE_REM_CTOR</a></li>
<li><a href="ref/tuple_reverse.html">TUPLE_REVERSE</a></li>
<li><a href="ref/tuple_to_list.html">TUPLE_TO_LIST</a></li>
<li><a href="ref/tuple_to_seq.html">TUPLE_TO_SEQ</a></li>
<!-- U -->
<li><a href="ref/update_counter.html">UPDATE_COUNTER</a></li>
<!-- V -->
<li><a href="ref/value.html">VALUE</a></li>
<!-- W -->
<li><a href="ref/while.html">WHILE</a></li>
<li><a href="ref/while_d.html">WHILE_<i>d</i></a></li>
<li><a href="ref/wstringize.html">WSTRINGIZE</a></li>
<!-- X -->
<li><a href="ref/xor.html">XOR</a></li>
</ul>
<!--
<EFBFBD> Copyright Housemarque Oy 2002
<EFBFBD> Copyright Paul Mensonides 2002
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)
-->
</body>
</html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>ref.html</title>
<link rel="stylesheet" type="text/css" href="styles.css">
<base target="desc">
</head>
<body>
<h4> Reference <small><a href="contents.html" target="index">[back]</a></small>
</h4>
<ul>
<!-- A -->
<li><a href="ref/add.html">ADD</a></li>
<li><a href="ref/add_d.html">ADD_D</a></li>
<li><a href="ref/and.html">AND</a></li>
<li><a href="ref/apply.html">APPLY</a></li>
<li><a href="ref/array_data.html">ARRAY_DATA</a></li>
<li><a href="ref/array_elem.html">ARRAY_ELEM</a></li>
<li><a href="ref/array_enum.html">ARRAY_ENUM</a></li>
<li><a href="ref/array_insert.html">ARRAY_INSERT</a></li>
<li><a href="ref/array_insert_d.html">ARRAY_INSERT_D</a></li>
<li><a href="ref/array_pop_back.html">ARRAY_POP_BACK</a></li>
<li><a href="ref/array_pop_back_z.html">ARRAY_POP_BACK_Z</a></li>
<li><a href="ref/array_pop_front.html">ARRAY_POP_FRONT</a></li>
<li><a href="ref/array_pop_front_z.html">ARRAY_POP_FRONT_Z</a></li>
<li><a href="ref/array_push_back.html">ARRAY_PUSH_BACK</a></li>
<li><a href="ref/array_push_front.html">ARRAY_PUSH_FRONT</a></li>
<li><a href="ref/array_remove.html">ARRAY_REMOVE</a></li>
<li><a href="ref/array_remove_d.html">ARRAY_REMOVE_D</a></li>
<li><a href="ref/array_replace.html">ARRAY_REPLACE</a></li>
<li><a href="ref/array_replace_d.html">ARRAY_REPLACE_D</a></li>
<li><a href="ref/array_reverse.html">ARRAY_REVERSE</a></li>
<li><a href="ref/array_size.html">ARRAY_SIZE</a></li>
<li><a href="ref/array_to_list.html">ARRAY_TO_LIST</a></li>
<li><a href="ref/array_to_seq.html">ARRAY_TO_SEQ</a></li>
<li><a href="ref/array_to_tuple.html">ARRAY_TO_TUPLE</a></li>
<li><a href="ref/assert.html">ASSERT</a></li>
<li><a href="ref/assert_msg.html">ASSERT_MSG</a></li>
<li><a href="ref/assign_slot.html">ASSIGN_SLOT</a></li>
<!-- B -->
<li><a href="ref/bitand.html">BITAND</a></li>
<li><a href="ref/bitnor.html">BITNOR</a></li>
<li><a href="ref/bitor.html">BITOR</a></li>
<li><a href="ref/bitxor.html">BITXOR</a></li>
<li><a href="ref/bool.html">BOOL</a></li>
<!-- C -->
<li><a href="ref/cat.html">CAT</a></li>
<li><a href="ref/check_empty.html">CHECK_EMPTY</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/comma.html">COMMA</a></li>
<li><a href="ref/comma_if.html">COMMA_IF</a></li>
<li><a href="ref/compl.html">COMPL</a></li>
<li><a href="ref/config_extended_line_info.html">CONFIG_EXTENDED_LINE_INFO</a></li>
<li><a href="ref/counter.html">COUNTER</a></li>
<!-- D -->
<li><a href="ref/dec.html">DEC</a></li>
<li><a href="ref/deduce_d.html">DEDUCE_D</a></li>
<li><a href="ref/deduce_r.html">DEDUCE_R</a></li>
<li><a href="ref/deduce_z.html">DEDUCE_Z</a></li>
<li><a href="ref/div.html">DIV</a></li>
<li><a href="ref/div_d.html">DIV_D</a></li>
<!-- E -->
<li><a href="ref/empty.html">EMPTY</a></li>
<li><a href="ref/enum.html">ENUM</a></li>
<li><a href="ref/enum_binary_params.html">ENUM_BINARY_PARAMS</a></li>
<li><a href="ref/enum_binary_params_z.html">ENUM_BINARY_PARAMS_Z</a></li>
<li><a href="ref/enum_params.html">ENUM_PARAMS</a></li>
<li><a href="ref/enum_params_with_a_default.html">ENUM_PARAMS_WITH_A_DEFAULT*</a></li>
<li><a href="ref/enum_params_with_defaults.html">ENUM_PARAMS_WITH_DEFAULTS*</a></li>
<li><a href="ref/enum_params_z.html">ENUM_PARAMS_Z</a></li>
<li><a href="ref/enum_shifted.html">ENUM_SHIFTED</a></li>
<li><a href="ref/esbp.html">ENUM_SHIFTED_BINARY_PARAMS</a></li>
<li><a href="ref/esbpz.html">ENUM_SHIFTED_BINARY_PARAMS_Z</a></li>
<li><a href="ref/enum_shifted_params.html">ENUM_SHIFTED_PARAMS</a></li>
<li><a href="ref/enum_shifted_params_z.html">ENUM_SHIFTED_PARAMS_Z</a></li>
<li><a href="ref/enum_shifted_z.html">ENUM_SHIFTED_<i>z</i></a></li>
<li><a href="ref/enum_trailing.html">ENUM_TRAILING</a></li>
<li><a href="ref/etbp.html">ENUM_TRAILING_BINARY_PARAMS</a></li>
<li><a href="ref/etbpz.html">ENUM_TRAILING_BINARY_PARAMS_Z</a></li>
<li><a href="ref/enum_trailing_params.html">ENUM_TRAILING_PARAMS</a></li>
<li><a href="ref/enum_trailing_params_z.html">ENUM_TRAILING_PARAMS_Z</a></li>
<li><a href="ref/enum_trailing_z.html">ENUM_TRAILING_<i>z</i></a></li>
<li><a href="ref/enum_z.html">ENUM_<i>z</i></a></li>
<li><a href="ref/equal.html">EQUAL</a></li>
<li><a href="ref/equal_d.html">EQUAL_D*</a></li>
<li><a href="ref/expand.html">EXPAND</a></li>
<li><a href="ref/expr_if.html">EXPR_IF</a></li>
<li><a href="ref/expr_iif.html">EXPR_IIF</a></li>
<!-- F -->
<li><a href="ref/filename_x.html">FILENAME_<i>x</i></a></li>
<li><a href="ref/for.html">FOR</a></li>
<li><a href="ref/for_r.html">FOR_<i>r</i></a></li>
<li><a href="ref/frame_finish.html">FRAME_FINISH</a></li>
<li><a href="ref/frame_flags.html">FRAME_FLAGS</a></li>
<li><a href="ref/frame_iteration.html">FRAME_ITERATION</a></li>
<li><a href="ref/frame_start.html">FRAME_START</a></li>
<!-- G -->
<li><a href="ref/greater.html">GREATER</a></li>
<li><a href="ref/greater_d.html">GREATER_D</a></li>
<li><a href="ref/greater_equal.html">GREATER_EQUAL</a></li>
<li><a href="ref/greater_equal_d.html">GREATER_EQUAL_D</a></li>
<!-- I -->
<li><a href="ref/identity.html">IDENTITY</a></li>
<li><a href="ref/identity_n.html">IDENTITY_N</a></li>
<li><a href="ref/if.html">IF</a></li>
<li><a href="ref/iif.html">IIF</a></li>
<li><a href="ref/inc.html">INC</a></li>
<li><a href="ref/include_self.html">INCLUDE_SELF</a></li>
<li><a href="ref/indirect_self.html">INDIRECT_SELF</a></li>
<li><a href="ref/intercept.html">INTERCEPT</a></li>
<li><a href="ref/is_begin_parens.html">IS_BEGIN_PARENS</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/is_iterating.html">IS_ITERATING</a></li>
<li><a href="ref/is_selfish.html">IS_SELFISH</a></li>
<li><a href="ref/is_standard.html">IS_STANDARD</a></li>
<li><a href="ref/iterate.html">ITERATE</a></li>
<li><a href="ref/iteration.html">ITERATION</a></li>
<li><a href="ref/iteration_depth.html">ITERATION_DEPTH</a></li>
<li><a href="ref/iteration_finish.html">ITERATION_FINISH</a></li>
<li><a href="ref/iteration_flags.html">ITERATION_FLAGS</a></li>
<li><a href="ref/iteration_limits.html">ITERATION_LIMITS</a></li>
<li><a href="ref/iteration_params_x.html">ITERATION_PARAMS_<i>x</i></a></li>
<li><a href="ref/iteration_start.html">ITERATION_START</a></li>
<!-- L -->
<li><a href="ref/less.html">LESS</a></li>
<li><a href="ref/less_d.html">LESS_D</a></li>
<li><a href="ref/less_equal.html">LESS_EQUAL</a></li>
<li><a href="ref/less_equal_d.html">LESS_EQUAL_D</a></li>
<li><a href="ref/limit_dim.html">LIMIT_DIM</a></li>
<li><a href="ref/limit_for.html">LIMIT_FOR</a></li>
<li><a href="ref/limit_iteration.html">LIMIT_ITERATION</a></li>
<li><a href="ref/limit_iteration_dim.html">LIMIT_ITERATION_DIM</a></li>
<li><a href="ref/limit_mag.html">LIMIT_MAG</a></li>
<li><a href="ref/limit_repeat.html">LIMIT_REPEAT</a></li>
<li><a href="ref/limit_seq.html">LIMIT_SEQ</a></li>
<li><a href="ref/limit_slot_count.html">LIMIT_SLOT_COUNT</a></li>
<li><a href="ref/limit_slot_sig.html">LIMIT_SLOT_SIG</a></li>
<li><a href="ref/limit_tuple.html">LIMIT_TUPLE</a></li>
<li><a href="ref/limit_variadic.html">LIMIT_VARIADIC</a></li>
<li><a href="ref/limit_while.html">LIMIT_WHILE</a></li>
<li><a href="ref/line.html">LINE</a></li>
<li><a href="ref/list_append.html">LIST_APPEND</a></li>
<li><a href="ref/list_append_d.html">LIST_APPEND_D</a></li>
<li><a href="ref/list_at.html">LIST_AT</a></li>
<li><a href="ref/list_at_d.html">LIST_AT_D</a></li>
<li><a href="ref/list_cat.html">LIST_CAT</a></li>
<li><a href="ref/list_cat_d.html">LIST_CAT_D</a></li>
<li><a href="ref/list_cons.html">LIST_CONS*</a></li>
<li><a href="ref/list_enum.html">LIST_ENUM</a></li>
<li><a href="ref/list_enum_r.html">LIST_ENUM_R</a></li>
<li><a href="ref/list_filter.html">LIST_FILTER</a></li>
<li><a href="ref/list_filter_d.html">LIST_FILTER_D</a></li>
<li><a href="ref/list_first.html">LIST_FIRST</a></li>
<li><a href="ref/list_first_n.html">LIST_FIRST_N</a></li>
<li><a href="ref/list_first_n_d.html">LIST_FIRST_N_D</a></li>
<li><a href="ref/list_fold_left.html">LIST_FOLD_LEFT</a></li>
<li><a href="ref/list_fold_left_2nd.html">LIST_FOLD_LEFT_2ND*</a></li>
<li><a href="ref/list_fold_left_2nd_d.html">LIST_FOLD_LEFT_2ND_D*</a></li>
<li><a href="ref/list_fold_left_d.html">LIST_FOLD_LEFT_<i>d</i></a></li>
<li><a href="ref/list_fold_left_d_old.html">LIST_FOLD_LEFT_D*</a></li>
<li><a href="ref/list_fold_right.html">LIST_FOLD_RIGHT</a></li>
<li><a href="ref/list_fold_right_2nd.html">LIST_FOLD_RIGHT_2ND*</a></li>
<li><a href="ref/list_fold_right_2nd_d.html">LIST_FOLD_RIGHT_2ND_D*</a></li>
<li><a href="ref/list_fold_right_d.html">LIST_FOLD_RIGHT_<i>d</i></a></li>
<li><a href="ref/list_fold_right_d_old.html">LIST_FOLD_RIGHT_D*</a></li>
<li><a href="ref/list_for_each.html">LIST_FOR_EACH</a></li>
<li><a href="ref/list_for_each_i.html">LIST_FOR_EACH_I</a></li>
<li><a href="ref/list_for_each_i_r.html">LIST_FOR_EACH_I_R</a></li>
<li><a href="ref/list_for_each_product.html">LIST_FOR_EACH_PRODUCT</a></li>
<li><a href="ref/list_for_each_product_r.html">LIST_FOR_EACH_PRODUCT_R</a></li>
<li><a href="ref/list_for_each_r.html">LIST_FOR_EACH_R</a></li>
<li><a href="ref/list_is_cons.html">LIST_IS_CONS</a></li>
<li><a href="ref/list_is_nil.html">LIST_IS_NIL</a></li>
<li><a href="ref/list_nil.html">LIST_NIL*</a></li>
<li><a href="ref/list_rest.html">LIST_REST</a></li>
<li><a href="ref/list_rest_n.html">LIST_REST_N</a></li>
<li><a href="ref/list_rest_n_d.html">LIST_REST_N_D</a></li>
<li><a href="ref/list_reverse.html">LIST_REVERSE</a></li>
<li><a href="ref/list_reverse_d.html">LIST_REVERSE_D</a></li>
<li><a href="ref/list_size.html">LIST_SIZE</a></li>
<li><a href="ref/list_size_d.html">LIST_SIZE_D</a></li>
<li><a href="ref/list_to_array.html">LIST_TO_ARRAY</a></li>
<li><a href="ref/list_to_array_d.html">LIST_TO_ARRAY_D</a></li>
<li><a href="ref/list_to_seq.html">LIST_TO_SEQ</a></li>
<li><a href="ref/list_to_seq_r.html">LIST_TO_SEQ_R</a></li>
<li><a href="ref/list_to_tuple.html">LIST_TO_TUPLE</a></li>
<li><a href="ref/list_to_tuple_r.html">LIST_TO_TUPLE_R</a></li>
<li><a href="ref/list_transform.html">LIST_TRANSFORM</a></li>
<li><a href="ref/list_transform_d.html">LIST_TRANSFORM_D</a></li>
<li><a href="ref/local_iterate.html">LOCAL_ITERATE</a></li>
<li><a href="ref/local_limits.html">LOCAL_LIMITS</a></li>
<li><a href="ref/local_macro.html">LOCAL_MACRO</a></li>
<li><a href="ref/lparen.html">LPAREN</a></li>
<li><a href="ref/lparen_if.html">LPAREN_IF</a></li>
<!-- M -->
<li><a href="ref/max.html">MAX</a></li>
<li><a href="ref/max_d.html">MAX_D</a></li>
<li><a href="ref/min.html">MIN</a></li>
<li><a href="ref/min_d.html">MIN_D</a></li>
<li><a href="ref/mod.html">MOD</a></li>
<li><a href="ref/mod_d.html">MOD_D</a></li>
<li><a href="ref/mul.html">MUL</a></li>
<li><a href="ref/mul_d.html">MUL_D</a></li>
<!-- N -->
<li><a href="ref/nil.html">NIL</a></li>
<li><a href="ref/nor.html">NOR</a></li>
<li><a href="ref/not.html">NOT</a></li>
<li><a href="ref/not_equal.html">NOT_EQUAL</a></li>
<li><a href="ref/not_equal_d.html">NOT_EQUAL_D*</a></li>
<!-- O -->
<li><a href="ref/or.html">OR</a></li>
<li><a href="ref/overload.html">OVERLOAD</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<!-- R -->
<li><a href="ref/relative_finish.html">RELATIVE_FINISH</a></li>
<li><a href="ref/relative_flags.html">RELATIVE_FLAGS</a></li>
<li><a href="ref/relative_iteration.html">RELATIVE_ITERATION</a></li>
<li><a href="ref/relative_start.html">RELATIVE_START</a></li>
<li><a href="ref/remove_parens.html">REMOVE_PARENS</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/repeat.html">REPEAT</a></li>
<li><a href="ref/repeat_1st.html">REPEAT_1ST*</a></li>
<li><a href="ref/repeat_2nd.html">REPEAT_2ND*</a></li>
<li><a href="ref/repeat_3rd.html">REPEAT_3RD*</a></li>
<li><a href="ref/repeat_from_to.html">REPEAT_FROM_TO</a></li>
<li><a href="ref/repeat_from_to_1st.html">REPEAT_FROM_TO_1ST*</a></li>
<li><a href="ref/repeat_from_to_2nd.html">REPEAT_FROM_TO_2ND*</a></li>
<li><a href="ref/repeat_from_to_3rd.html">REPEAT_FROM_TO_3RD*</a></li>
<li><a href="ref/repeat_from_to_d.html">REPEAT_FROM_TO_D</a></li>
<li><a href="ref/repeat_from_to_d_z.html">REPEAT_FROM_TO_D_<i>z</i></a></li>
<li><a href="ref/repeat_from_to_z.html">REPEAT_FROM_TO_<i>z</i></a></li>
<li><a href="ref/repeat_z.html">REPEAT_<i>z</i></a></li>
<li><a href="ref/rparen.html">RPAREN</a></li>
<li><a href="ref/rparen_if.html">RPAREN_IF</a></li>
<!-- S -->
<li><a href="ref/seq_cat.html">SEQ_CAT</a></li>
<li><a href="ref/seq_cat_s.html">SEQ_CAT_S</a></li>
<li><a href="ref/seq_elem.html">SEQ_ELEM</a></li>
<li><a href="ref/seq_enum.html">SEQ_ENUM</a></li>
<li><a href="ref/seq_filter.html">SEQ_FILTER</a></li>
<li><a href="ref/seq_filter_s.html">SEQ_FILTER_S</a></li>
<li><a href="ref/seq_first_n.html">SEQ_FIRST_N</a></li>
<li><a href="ref/seq_fold_left.html">SEQ_FOLD_LEFT</a></li>
<li><a href="ref/seq_fold_left_s.html">SEQ_FOLD_LEFT_<i>s</i></a></li>
<li><a href="ref/seq_fold_right.html">SEQ_FOLD_RIGHT</a></li>
<li><a href="ref/seq_fold_right_s.html">SEQ_FOLD_RIGHT_<i>s</i></a></li>
<li><a href="ref/seq_for_each.html">SEQ_FOR_EACH</a></li>
<li><a href="ref/seq_for_each_i.html">SEQ_FOR_EACH_I</a></li>
<li><a href="ref/seq_for_each_i_r.html">SEQ_FOR_EACH_I_R</a></li>
<li><a href="ref/seq_for_each_product.html">SEQ_FOR_EACH_PRODUCT</a></li>
<li><a href="ref/seq_for_each_product_r.html">SEQ_FOR_EACH_PRODUCT_R</a></li>
<li><a href="ref/seq_for_each_r.html">SEQ_FOR_EACH_R</a></li>
<li><a href="ref/seq_head.html">SEQ_HEAD</a></li>
<li><a href="ref/seq_insert.html">SEQ_INSERT</a></li>
<li><a href="ref/seq_nil.html">SEQ_NIL</a></li>
<li><a href="ref/seq_pop_back.html">SEQ_POP_BACK</a></li>
<li><a href="ref/seq_pop_front.html">SEQ_POP_FRONT</a></li>
<li><a href="ref/seq_push_back.html">SEQ_PUSH_BACK</a></li>
<li><a href="ref/seq_push_front.html">SEQ_PUSH_FRONT</a></li>
<li><a href="ref/seq_remove.html">SEQ_REMOVE</a></li>
<li><a href="ref/seq_replace.html">SEQ_REPLACE</a></li>
<li><a href="ref/seq_rest_n.html">SEQ_REST_N</a></li>
<li><a href="ref/seq_reverse.html">SEQ_REVERSE</a></li>
<li><a href="ref/seq_reverse_s.html">SEQ_REVERSE_S</a></li>
<li><a href="ref/seq_size.html">SEQ_SIZE</a></li>
<li><a href="ref/seq_subseq.html">SEQ_SUBSEQ</a></li>
<li><a href="ref/seq_tail.html">SEQ_TAIL</a></li>
<li><a href="ref/seq_to_array.html">SEQ_TO_ARRAY</a></li>
<li><a href="ref/seq_to_list.html">SEQ_TO_LIST</a></li>
<li><a href="ref/seq_to_tuple.html">SEQ_TO_TUPLE</a></li>
<li><a href="ref/seq_transform.html">SEQ_TRANSFORM</a></li>
<li><a href="ref/seq_transform_s.html">SEQ_TRANSFORM_S</a></li>
<li><a href="ref/slot.html">SLOT</a></li>
<li><a href="ref/stringize.html">STRINGIZE</a></li>
<li><a href="ref/sub.html">SUB</a></li>
<li><a href="ref/sub_d.html">SUB_D</a></li>
<!-- T -->
<li><a href="ref/tuple_eat.html">TUPLE_EAT</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_elem.html">TUPLE_ELEM</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_enum.html">TUPLE_ENUM</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><span style="color: gray;"></span><a href="ref/tuple_insert.html">TUPLE_INSERT</a>
<a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_insert_d.html">TUPLE_INSERT_D</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_pop_back.html">TUPLE_POP_BACK</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_pop_back_z.html">TUPLE_POP_BACK_Z</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_pop_front.html">TUPLE_POP_FRONT</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_pop_front_z.html">TUPLE_POP_FRONT_Z</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_push_back.html">TUPLE_PUSH_BACK</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_push_front.html">TUPLE_PUSH_FRONT</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_rem.html">TUPLE_REM</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_rem_ctor.html">TUPLE_REM_CTOR</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_remove.html">TUPLE_REMOVE</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_remove_d.html">TUPLE_REMOVE_D</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_replace.html">TUPLE_REPLACE</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_replace_d.html">TUPLE_REPLACE_D</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_reverse.html">TUPLE_REVERSE</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_size.html">TUPLE_SIZE</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_to_array.html">TUPLE_TO_ARRAY</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_to_list.html">TUPLE_TO_LIST</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/tuple_to_seq.html">TUPLE_TO_SEQ</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<!-- U -->
<li><a href="ref/update_counter.html">UPDATE_COUNTER</a></li>
<!-- V -->
<li><a href="ref/va_opt.html">VA_OPT</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/value.html">VALUE</a></li>
<li><a href="ref/variadics.html">VARIADICS</a></li>
<li><a href="ref/variadic_elem.html">VARIADIC_ELEM</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/variadic_has_opt.html">VARIADIC_HAS_OPT</a></li>
<li><a href="ref/variadic_seq_to_seq.html">VARIADIC_SEQ_TO_SEQ</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/variadic_size.html">VARIADIC_SIZE</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/variadic_to_array.html">VARIADIC_TO_ARRAY</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/variadic_to_list.html">VARIADIC_TO_LIST</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/variadic_to_seq.html">VARIADIC_TO_SEQ</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<li><a href="ref/variadic_to_tuple.html">VARIADIC_TO_TUPLE</a> <a href="topics/variadic_macros.html#VNotation">(v)</a></li>
<!-- W -->
<li><a href="ref/while.html">WHILE</a></li>
<li><a href="ref/while_d.html">WHILE_<i>d</i></a></li>
<li><a href="ref/wstringize.html">WSTRINGIZE</a></li>
<!-- X -->
<li><a href="ref/xor.html">XOR</a></li>
</ul>
<!--
© Copyright Housemarque Oy 2002© Copyright Paul Mensonides 2002
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)-->
</body>
</html>

View File

@ -34,7 +34,7 @@
It is more efficient, however, to use <b>BOOST_PP_ADD_D</b> in such a situation.
</div>
<div>
This macro is the most efficient when <i>x</i> is less than or equal to <i>y</i>.&nbsp;
This macro is the most efficient when <i>x</i> is greater than or equal to <i>y</i>.&nbsp;
However, the efficiency gain is not worth actually comparing the two arguments prior to invocation.&nbsp;
In other words, <i>x</i> should be the addend that is <i>most likely</i> to be the largest of the two operands.
</div>

View File

@ -34,7 +34,7 @@
If the sum of <i>x</i> and <i>y</i> is greater than <b>BOOST_PP_LIMIT_MAG</b>, the result is saturated to <b>BOOST_PP_LIMIT_MAG</b>.
</div>
<div>
This macro is the most efficient when <i>x</i> is less than or equal to <i>y</i>.&nbsp;
This macro is the most efficient when <i>x</i> is greater than or equal to <i>y</i>.&nbsp;
However, the efficiency gain is not worth actually comparing the two arguments prior to invocation.&nbsp;
In other words, <i>x</i> should be the addend that is <i>most likely</i> to be the largest of the two operands.
</div>

52
doc/ref/array_enum.html Normal file
View File

@ -0,0 +1,52 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=windows-1252">
<title>BOOST_PP_ARRAY_ENUM</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_ARRAY_ENUM</b>
macro converts an <i>array</i> to its comma-separated elements.
The comma-separated elements are in the form of <i>variadic data</i>.<br>
</div>
<h4> Usage </h4>
<div class="code"> <b>BOOST_PP_ARRAY_ENUM</b>(<i>array</i>) </div>
<h4> Arguments </h4>
<dl>
<dt>array</dt>
<dd> The <i>array</i> whose elements are to be converted. </dd>
</dl>
<h4> Remarks </h4>
<div> This macro expands to a comma-separated list of the elements
in <i>array</i>.&nbsp;
For example, <b>BOOST_PP_ARRAY_ENUM</b>((3,(<i>x,</i><i>y,</i><i>z</i>)))
expands
to...
<div> <i>x</i>, <i>y</i>, <i>z<br>
</i> </div>
</div>
<p>&nbsp;&nbsp;&nbsp; In <a
href="file:///E:/Programming/VersionControl/modular-boost/libs/preprocessor/doc/topics/variadic_macros.html#C20_Support_For_Variadic_Macros">C++
20</a> mode if the array is empty the resulting <i>variadic</i>
<i>data</i> will be empty.</p>
<h4> </h4>
<h4>Requirements </h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/array/enum.html">&lt;boost/preprocessor/array/enum.hpp&gt;</a>
</div>
<h4> Sample Code </h4>
<div>
<pre>#include &lt;<a href="../headers/array/enum.html">boost/preprocessor/array/enum.hpp</a>&gt;<br><br>#define ARRAY (5,(B,O,O,S,T))<br><br><a href="array_enum.html">BOOST_PP_ARRAY_ENUM</a>(ARRAY) // expands to B, O, O, S, T<br></pre>
</div>
<hr size="1">
<div style="margin-left: 0px;"> <i></i><i><EFBFBD> Copyright Edward Diener
2011</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version
1.0.
(See accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,59 +1,51 @@
<html>
<head>
<title>BOOST_PP_ARRAY_POP_FRONT</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_ARRAY_POP_FRONT</b> macro pops an element from the end of an <i>array</i>.
</div>
<h4>Usage</h4>
<div class="code">
<b>BOOST_PP_ARRAY_POP_FRONT</b>(<i>array</i>)
</div>
<h4>Arguments</h4>
<dl>
<dt>array</dt>
<dd>
The <i>array</i> to pop an element from.
</dd>
</dl>
<h4>Remarks</h4>
<div>
This macro returns <i>array</i> after removing the first element.&nbsp;
If <i>array</i> has no elements, the result of applying this macro is undefined.
</div>
<div>
This macro uses <b>BOOST_PP_REPEAT</b> internally.&nbsp;
Therefore, to use the <i>z</i> parameter passed from other macros that use
<b>BOOST_PP_REPEAT</b>, see <b>BOOST_PP_ARRAY_POP_FRONT_Z</b>
</div>
<h4>See Also</h4>
<ul>
<li><a href="array_pop_front_z.html">BOOST_PP_ARRAY_POP_FRONT_Z</a></li>
</ul>
<h4>Requirements</h4>
<div>
<b>Header:</b> &nbsp;<a href="../headers/array/pop_front.html">&lt;boost/preprocessor/array/pop_front.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div><pre>
#include &lt;<a href="../headers/array/pop_front.html">boost/preprocessor/array/pop_front.hpp</a>&gt;
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_ARRAY_POP_FRONT</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_ARRAY_POP_FRONT</b> macro
pops an element from the beginning of an <i>array</i>.</div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_ARRAY_POP_FRONT</b>(<i>array</i>) </div>
<h4>Arguments</h4>
<dl>
<dt>array</dt>
<dd> The <i>array</i> to pop an element from. </dd>
</dl>
<h4>Remarks</h4>
<div> This macro returns <i>array</i> after removing the first
element.&nbsp; If <i>array</i> has no elements, the result of applying
this macro is undefined. </div>
<div> This macro uses <b>BOOST_PP_REPEAT</b> internally.&nbsp; Therefore,
to use the <i>z</i> parameter passed from other macros that use <b>BOOST_PP_REPEAT</b>,
see <b>BOOST_PP_ARRAY_POP_FRONT_Z</b> </div>
<h4>See Also</h4>
<ul>
<li><a href="array_pop_front_z.html">BOOST_PP_ARRAY_POP_FRONT_Z</a></li>
</ul>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/array/pop_front.html">&lt;boost/preprocessor/array/pop_front.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div>
<pre>#include &lt;<a href="../headers/array/pop_front.html">boost/preprocessor/array/pop_front.hpp</a>&gt;
#define ARRAY (3, (a, b, c))
<a href="array_pop_front.html">BOOST_PP_ARRAY_POP_FRONT</a>(ARRAY) // expands to (2, (b, c))
</pre></div>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a href="http://www.housemarque.com"
target="_top">Housemarque Oy</a> 2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002<br>
</i><i><EFBFBD> Copyright Edward Diener 2013</i><br>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,41 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_ARRAY_TO_LIST</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_ARRAY_TO_LIST</b> macro
converts an <i>array</i> to a <i>list</i>. </div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_ARRAY_TO_LIST</b>(<i>array</i>) </div>
<h4>Arguments</h4>
<dl>
<dt>array</dt>
<dd> The <i>array</i> to be converted.</dd>
</dl>
<ul>
</ul>
<h4>Remarks</h4>
<p>&nbsp;&nbsp;&nbsp; If the <i>array</i> to be converted is empty, as
represented by '( 0, () )', the resulting <i>list</i> is empty, as
represented by 'BOOST_PP_NIL'.</p>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/array/to_list.html">&lt;boost/preprocessor/array/to_list.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div>
<pre>#include &lt;<a href="../headers/array/to_list.html">boost/preprocessor/array/to_list.hpp</a>&gt;<br><br><a
href="array_to_list.html">BOOST_PP_ARRAY_TO_LIST</a>((3, (x, y, z)))<br> // expands to (x, (y, (z, <a
href="nil.html">BOOST_PP_NIL</a>)))</pre>
</div>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2011</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
s
</body>
</html>

37
doc/ref/array_to_seq.html Normal file
View File

@ -0,0 +1,37 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_ARRAY_TO_SEQ</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_ARRAY_TO_SEQ</b> macro
converts an <i>array</i> to a <i>seq</i>. </div>
<h4> Usage </h4>
<div class="code"> <b>BOOST_PP_ARRAY_TO_SEQ</b>(<i>array</i>) </div>
<h4> Arguments </h4>
<dl>
<dt>array</dt>
<dd> The <i>array</i> to be converted.</dd>
</dl>
<h4>Remarks</h4>
<p>&nbsp;&nbsp;&nbsp; If the <i>array</i> to be converted is empty, as
represented by '( 0, () )', the resulting <i>seq</i> is undefined since a
<i>seq</i> cannot be empty.</p>
<h4>Requirements </h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/array/to_seq.html">&lt;boost/preprocessor/array/to_seq.hpp&gt;</a>
</div>
<h4> Sample Code </h4>
<div>
<pre>#include &lt;<a href="../headers/array/to_seq.html">boost/preprocessor/array/to_seq.hpp</a>&gt;<br><br><a
href="array_to_seq.html">BOOST_PP_ARRAY_TO_SEQ</a>((3, (a, b, c))) // expands to (a)(b)(c)</pre>
</div>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2011</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,39 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_ARRAY_TO_TUPLE</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_ARRAY_TO_TUPLE</b> macro
converts an <i>array</i> to an <i>tuple</i>. </div>
<h4> Usage </h4>
<div class="code"> <b>BOOST_PP_ARRAY_TO_TUPLE</b>(<i>array</i>) </div>
<h4> Arguments </h4>
<dl>
<dt>array</dt>
<dd> The <i>array</i> to be converted.</dd>
</dl>
<h4>Remarks</h4>
<p>&nbsp;&nbsp;&nbsp; If the <i>array</i> to be converted is empty, as
represented by '( 0, () )', the resulting <i>tuple</i> is undefined
since a <i>tuple</i> cannot be empty.</p>
<h4>Requirements </h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/array/to_tuple.html">&lt;boost/preprocessor/array/to_tuple.hpp&gt;</a>
</div>
<h4> Sample Code </h4>
<div>
<pre>#include &lt;<a href="../headers/array/to_tuple.html">boost/preprocessor/array/to_tuple.hpp</a>&gt;<br><br>#define ARRAY (3,(a, b, c))<br><br><a
href="array_to_tuple.html">BOOST_PP_ARRAY_TO_TUPLE</a>(ARRAY) // expands to (a, b, c)</pre>
</div>
<hr size="1">
<div style="margin-left: 0px;"> <i></i><i><EFBFBD> Copyright Edward Diener 2011</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

68
doc/ref/check_empty.html Normal file
View File

@ -0,0 +1,68 @@
<html>
<head>
<title>BOOST_PP_CHECK_EMPTY</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_CHECK_EMPTY</b> variadic macro
checks to see if its variadic input is empty or not. It expands to 1 if its input
is empty and expands to 0 if its input is not empty. The macro only exists when
the compilation is at the C++20 level and the __VA_OPT__ construct is supported.</div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_CHECK_EMPTY</b>(<i>...</i>) <a href="../topics/variadic_macros.html#VNotation" target="_self"><sup>(v)</sup></a><br>
</div>
<h4>Arguments</h4>
<dl>
<dt>...<br>
</dt>
<dd> The <i>variadic data</i> to be checked for emptiness. </dd>
</dl>
<h4>Remarks</h4>
<div>
When the macro invocation BOOST_PP_VARIADIC_HAS_OPT() expands to 1, then this
macro exists and can be invoked, otherwise this macro does not exist
and attempting to invoke it will lead to a preprocessor error that the macro
can not be found. Because of this condition the header file for including
this macro includes the header file for the BOOST_PP_VARIADIC_HAS_OPT macro.<br>
It is possible to pass data to this macro which expands to nothing, in which
case this macro will expand to 1 just as if nothing has been passed.
</div>
<h4>See Also</h4>
<ul>
<li><a href="variadic_has_opt.html">BOOST_PP_VARIADIC_HAS_OPT</a></li>
</ul>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/facilities/check_empty.html">&lt;boost/preprocessor/facilities/check_empty.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div>
<pre>
#include &lt;<a href="../headers/facilities/check_empty.html">boost/preprocessor/facilities/check_empty.hpp</a>&gt;
# if <a href="variadic_has_opt.html">BOOST_PP_VARIADIC_HAS_OPT</a>()
#define DATA
#define OBJECT OBJECT2
#define OBJECT2
#define FUNC(x) FUNC2(x)
#define FUNC2(x)
#define FUNC_GEN(x,y) (1,2,3)
<a href="check_empty.html">BOOST_PP_CHECK_EMPTY</a>(DATA) // expands to 1
<a href="check_empty.html">BOOST_PP_CHECK_EMPTY</a>(OBJECT) // expands to 1
<a href="check_empty.html">BOOST_PP_CHECK_EMPTY</a>(FUNC(1)) // expands to 1
<a href="check_empty.html">BOOST_PP_CHECK_EMPTY</a>(FUNC) // expands to 0
<a href="check_empty.html">BOOST_PP_CHECK_EMPTY</a>(FUNC_GEN) // expands to 0
#endif
</pre>
</div>
<hr size="1">
<div style="margin-left: 0px;"> <i></i><i><EFBFBD> Copyright Edward Diener 2019</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0.
(See accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -64,10 +64,10 @@
#include &lt;<a href="../headers/repetition/epwd.html">boost/preprocessor/repetition/enum_params_with_defaults.hpp</a>&gt;
<a href="enum_params_with_defaults.html">BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS</a>(3, class T, U)
// expands to T0 = U0, T1 = U1, T2 = U2
// expands to class T0 = U0, class T1 = U1, class T2 = U2
<a href="enum_binary_params.html">BOOST_PP_ENUM_BINARY_PARAMS</a>(3, class T, = U)
// expands to T0 = U0, T1 = U1, T2 = U2
// expands to class T0 = U0, class T1 = U1, class T2 = U2
</pre></div>
<hr size="1">
<div style="margin-left: 0px;">

View File

@ -22,7 +22,7 @@
<div>
This macro is useful when a delay is necessary to produce the correct semantics of a macro invocation.&nbsp;
For example, when a macro expands to an argument list to another macro.&nbsp;
This macro will expand the the argument list on the first pass, and then rescan to expand any more macros.
This macro will expand the argument list on the first pass, and then rescan to expand any more macros.
</div>
<h4>Requirements</h4>
<div>

View File

@ -1,75 +1,68 @@
<html>
<head>
<title>BOOST_PP_FOR_r</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_FOR_<i>r</i></b> macro represents a reentry into the <b>BOOST_PP_FOR</b> repetition construct.
</div>
<h4>Usage</h4>
<div class="code">
<b>BOOST_PP_FOR_</b> ## <i>r</i>(<i>state</i>, <i>pred</i>, <i>op</i>, <i>macro</i>)
</div>
<h4>Arguments</h4>
<dl>
<dt>r</dt>
<dd>
The next available <b>BOOST_PP_FOR</b> repetition.
</dd>
<dt>state</dt>
<dd>
The initial state.
</dd>
<dt>pred</dt>
<dd>
A binary predicate of the form <i>pred</i>(<i>r</i>, <i>state</i>).&nbsp;
This macro must expand to an integer in the range of <i>0</i> to <b>BOOST_PP_LIMIT_MAG</b>.&nbsp;
<b>BOOST_PP_FOR</b> repeatedly expands <i>macro</i> while this predicate returns non-zero.&nbsp;
This macro is called with the next available <b>BOOST_PP_FOR</b> repetition and the current <i>state</i>.
</dd>
<dt>op</dt>
<dd>
A binary operation of the form <i>op</i>(<i>r</i>, <i>state</i>).&nbsp;
This operation is expanded by <b>BOOST_PP_FOR</b> with the next available <b>BOOST_PP_FOR</b> repetition and the current <i>state</i>.&nbsp;
This macro is repeatedly applied to the <i>state</i>, each time producing a new <i>state</i>, until <i>pred</i> returns <i>0</i>.
</dd>
<dt>macro</dt>
<dd>
A binary macro of the form <i>macro</i>(<i>r</i>, <i>state</i>).&nbsp;
This macro is expanded by <b>BOOST_PP_FOR</b> with the next available <b>BOOST_PP_FOR</b> repetition and the current <i>state</i>.&nbsp;
This macro is is repeated by <b>BOOST_PP_FOR</b> until <i>pred</i> returns <i>0</i>.
</dd>
</dl>
<h4>Remarks</h4>
<div>
This macro expands to the sequence:
<div>
<i>macro</i>(<i>r</i>, <i>state</i>) <i>macro</i>(<i>r</i>, <i>op</i>(<i>r</i>, <i>state</i>)) ... <i>macro</i>(<i>r</i>, <i>op</i>(<i>r</i>, ... <i>op</i>(<i>r</i>, <i>state</i>) ... ))
</div>
</div>
<div>
At certain times, it may be necessary to perform the concatenation with <b>BOOST_PP_CAT</b> rather than the preprocessor token-pasting operator.&nbsp;
This happens when the <i>r</i> value is a macro invocation itself.&nbsp;
It needs a delay to allow it to expand.&nbsp;
The syntax in such a scenario becomes:
<div>
<b>BOOST_PP_CAT</b>(<b>BOOST_PP_FOR_</b>, <i>r</i>)(<i>state</i>, <i>pred</i>, <i>op</i>, <i>macro</i>)
</div>
</div>
<h4>See Also</h4>
<ul>
<li><a href="cat.html">BOOST_PP_CAT</a></li>
<li><a href="for.html">BOOST_PP_FOR</a></li>
<li><a href="limit_mag.html">BOOST_PP_LIMIT_MAG</a></li>
</ul>
<h4>Requirements</h4>
<div>
<b>Header:</b> &nbsp;<a href="../headers/repetition/for.html">&lt;boost/preprocessor/repetition/for.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div><pre>
#include &lt;<a href="../headers/arithmetic/dec.html">boost/preprocessor/arithmetic/dec.hpp</a>&gt;
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_FOR_r</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_FOR_<i>r</i></b> macro
represents a reentry into the <b>BOOST_PP_FOR</b> repetition construct. </div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_FOR_</b> ## <i>r</i>(<i>state</i>, <i>pred</i>,
<i>op</i>, <i>macro</i>) </div>
<h4>Arguments</h4>
<dl>
<dt>r</dt>
<dd> The next available <b>BOOST_PP_FOR</b> repetition. </dd>
<dt>state</dt>
<dd> The initial state. </dd>
<dt>pred</dt>
<dd> A binary predicate of the form <i>pred</i>(<i>r</i>, <i>state</i>).&nbsp;
This macro must expand to an integer in the range of <i>0</i> to <b>BOOST_PP_LIMIT_MAG</b>.&nbsp;
<b>BOOST_PP_FOR</b> repeatedly expands <i>macro</i> while this
predicate returns non-zero.&nbsp; This macro is called with the next
available <b>BOOST_PP_FOR</b> repetition and the current <i>state</i>.
</dd>
<dt>op</dt>
<dd> A binary operation of the form <i>op</i>(<i>r</i>, <i>state</i>).&nbsp;
This operation is expanded by <b>BOOST_PP_FOR</b> with the next
available <b>BOOST_PP_FOR</b> repetition and the current <i>state</i>.&nbsp;
This macro is repeatedly applied to the <i>state</i>, each time
producing a new <i>state</i>, until <i>pred</i> returns <i>0</i>. </dd>
<dt>macro</dt>
<dd> A binary macro of the form <i>macro</i>(<i>r</i>, <i>state</i>).&nbsp;
This macro is expanded by <b>BOOST_PP_FOR</b> with the next available <b>BOOST_PP_FOR</b>
repetition and the current <i>state</i>.&nbsp; This macro is is
repeated by <b>BOOST_PP_FOR</b> until <i>pred</i> returns <i>0</i>. </dd>
</dl>
<h4>Remarks</h4>
<div> This macro expands to the sequence:
<div> <i>macro</i>(<i>r</i>, <i>state</i>) <i>macro</i>(<i>r</i>, <i>op</i>(<i>r</i>,
<i>state</i>)) ... <i>macro</i>(<i>r</i>, <i>op</i>(<i>r</i>, ... <i>op</i>(<i>r</i>,
<i>state</i>) ... )) </div>
</div>
<div> At certain times, it may be necessary to perform the concatenation
with <b>BOOST_PP_CAT</b> rather than the preprocessor token-pasting
operator.&nbsp; This happens when the <i>r</i> value is a macro
invocation itself.&nbsp; It needs a delay to allow it to expand.&nbsp; The
syntax in such a scenario becomes:
<div> <b>BOOST_PP_CAT</b>(<b>BOOST_PP_FOR_</b>, <i>r</i>)(<i>state</i>,
<i>pred</i>, <i>op</i>, <i>macro</i>) </div>
</div>
<h4>See Also</h4>
<ul>
<li><a href="cat.html">BOOST_PP_CAT</a></li>
<li><a href="for.html">BOOST_PP_FOR</a></li>
<li><a href="limit_mag.html">BOOST_PP_LIMIT_MAG</a></li>
<li><a href="for_r_macros.html"><span style="color: gray;">Macros with R
re-entrancy forms</span></a></li>
</ul>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/repetition/for.html">&lt;boost/preprocessor/repetition/for.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div>
<pre>#include &lt;<a href="../headers/arithmetic/dec.html">boost/preprocessor/arithmetic/dec.hpp</a>&gt;
#include &lt;<a href="../headers/arithmetic/inc.html">boost/preprocessor/arithmetic/inc.hpp</a>&gt;
#include &lt;<a href="../headers/comparison/not_equal.html">boost/preprocessor/comparison/not_equal.hpp</a>&gt;
#include &lt;<a href="../headers/punctuation/comma_if.html">boost/preprocessor/punctuation/comma_if.hpp</a>&gt;
@ -140,16 +133,16 @@ TEMPLATE_TEMPLATE(2, 4, T)
template&lt;class, class, class, class&gt; class T4
*/
</pre></div>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a href="http://www.housemarque.com"
target="_top">Housemarque Oy</a> 2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002<br>
</i><i><EFBFBD> Copyright Edward Diener 2014</i><br>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

44
doc/ref/for_r_macros.html Normal file
View File

@ -0,0 +1,44 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_FOR_r_macros</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>This is a list, based on functionality, of the macros which have an
alternate <b>_<i>r</i></b> name, representing a reentry into the <b>BOOST_PP_FOR</b>
looping construct:
<p>repetition</p>
<ul>
<li><a href="deduce_r.html">BOOST_PP_DEDUCE_R</a></li>
</ul>
list<br>
<ul>
<li><a href="list_enum_r.html">BOOST_PP_LIST_ENUM_R</a></li>
<li><a href="list_for_each_i_r.html">BOOST_PP_LIST_FOR_EACH_I_R</a></li>
<li><a href="list_for_each_product_r.html">BOOST_PP_LIST_FOR_EACH_PRODUCT_R</a></li>
<li><a href="list_for_each_r.html">BOOST_PP_LIST_FOR_EACH_R</a></li>
<li><a href="list_to_seq_r.html">BOOST_PP_LIST_TO_SEQ_R</a></li>
<li><a href="list_to_tuple_r.html">BOOST_PP_LIST_TO_TUPLE_R</a></li>
</ul>
seq<br>
<ul>
<li><a href="seq_for_each_product_r.html">BOOST_PP_SEQ_FOR_EACH_PRODUCT_R</a></li>
<li><a href="seq_for_each_r.html">BOOST_PP_SEQ_FOR_EACH_R</a></li>
</ul>
base<br>
<ul>
<li><a href="for_r.html">BOOST_PP_FOR_R</a><br>
</li>
</ul>
<br>
<ul>
</ul>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2014</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

58
doc/ref/identity_n.html Normal file
View File

@ -0,0 +1,58 @@
<html>
<head>
<title>BOOST_PP_IDENTITY_N</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_IDENTITY_N</b> macro expands to its first argument when invoked.
</div>
<h4>Usage</h4>
<div class="code">
<b>BOOST_PP_IDENTITY_N</b>(<i>item,n</i>)(n-arguments)
</div>
<h4>Arguments</h4>
<dl>
<dt>item</dt>
<dd>
The result of the expansion.
</dd>
<dt>n</dt>
<dd>
The number of arguments when invoked.
</dd>
</dl>
<h4>Remarks</h4>
<div>
This macro is designed to be used with <b>BOOST_PP_IF</b> and <b>BOOST_PP_IIF</b> when only one of the clauses needs to be invoked.
</div>
<h4>See Also</h4>
<ul>
<li><a href="if.html">BOOST_PP_IF</a></li>
<li><a href="iif.html">BOOST_PP_IIF</a></li>
</ul>
<h4>Requirements</h4>
<div>
<b>Header:</b> &nbsp;<a href="../headers/facilities/identity.html">&lt;boost/preprocessor/facilities/identity.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div><pre>
#include &lt;<a href="../headers/control/if.html">boost/preprocessor/control/if.hpp</a>&gt;
#include &lt;<a href="../headers/facilities/identity.html">boost/preprocessor/facilities/identity.hpp</a>&gt;
#define MACRO_CAT(y,z) y ## z
#define MACRO(n) <a href="if.html">BOOST_PP_IF</a>(n, <a href="identity_n.html">BOOST_PP_IDENTITY_N</a>(x,2), MACRO_CAT)(a,b)
MACRO(0) // expands to ab
MACRO(1) // expands to x
</pre></div>
<hr size="1">
<div style="margin-left: 0px"><i>&copy; Copyright Edward Diener 2015</i></div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -44,7 +44,7 @@
<h4>Sample Code</h4>
<div><pre>
#include &lt;<a href="../headers/control/iif.html">boost/preprocessor/control/iif.hpp</a>&gt;
#include &lt;<a href="../headers/logical/or.html">boost/preprocessor/logical/or.hpp</a>
#include &lt;<a href="../headers/logical/or.html">boost/preprocessor/logical/or.hpp</a>&gt;
#define OR_IF(p, q, t, f) <a href="iif.html">BOOST_PP_IIF</a>(<a href="or.html">BOOST_PP_OR</a>(p, q), t, f)

View File

@ -0,0 +1,47 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_IS_BEGIN_PARENS</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_IS_BEGIN_PAREN</b>S
determines whether the input starts with a set of parenthesis.</div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_IS_BEGIN_PARENS</b>(...) <a href="../topics/variadic_macros.html#VNotation"
target="_self"><sup>(v)</sup></a></div>
<h4>Arguments</h4>
<h4>&nbsp;&nbsp;&nbsp; ...&nbsp;&nbsp;&nbsp; <span style="font-weight: normal;">&nbsp;&nbsp;&nbsp;
&nbsp;&nbsp;&nbsp; The input as variadic data.</span></h4>
<h4>Remarks</h4>
<div> If the input input begins with a parenthesis, with any data within
that parenthesis, the macro returns 1, otherwise it returns 0. Data may
follow the beginning parenthesis and the macro still will return 1.<br>
<br>
For Visual Studio 2005 ( VC8 ) the input data must be a single parameter
else a compilation error will occur.</div>
<h4>See Also</h4>
<ul>
<li><a href="remove_parens.html">BOOST_PP_REMOVE_PARENS</a></li>
</ul>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/punctuation/is_begin_parens.html">&lt;boost/preprocessor/punctuation/is_begin_parens.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div>
<pre>#include &lt;<a href="../headers/punctuation/is_begin_parens.html">boost/preprocessor/punctuation/is_begin_parens.hpp</a>&gt;
#define VARDATA more_data , more_params<br>#define VARDATAP ( data ) more_data , more_params<br>#define DATA data<br>#define DATAP ( data ) more_data<br>
BOOST_PP_IS_BEGIN_PARENS(VARDATA) // expands to 0, compiler error with VC8
BOOST_PP_IS_BEGIN_PARENS(VARDATAP) // expands to 1, compiler error with VC8<br><br>BOOST_PP_IS_BEGIN_PARENS(DATA) // expands to 0
BOOST_PP_IS_BEGIN_PARENS(DATAP) // expands to 1<br><br>BOOST_PP_IS_BEGIN_PARENS() // expands to 0<br>
</pre></div>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2014</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

44
doc/ref/is_standard.html Normal file
View File

@ -0,0 +1,44 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=windows-1252">
<title>BOOST_PP_IS_STANDARD</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_IS_STANDARD </b>macro
specifies whether the compiler's preprocessor is a standard
conforming one or not.<br>
</div>
<h4>Usage</h4>
<div class="code"><b>BOOST_PP_IS_STANDARD()</b><br>
</div>
<b>Remarks</b>
<div> The macro is a <i>function-like</i> macro taking no
parameters. It is used to check if the compiler's preprocessor is
standard conforming. One use for the end-user is to see if <a
href="../topics/limitations.html">limitations</a> can be
changed, since changes will only take affect for standard
conforming preprocessors. The macro expands to 1 if
the compiler's preprocessor is standard conforming and 0 if it is
not.</div>
<b>Requirements</b>
<div> <b>Header:</b> &nbsp;<a
href="../headers/config/variadics.html">&lt;boost/preprocessor/config/config.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div>
<pre>// Beginning of source file<br><br>#include &lt;<a href="../headers/config/variadics.html">boost/preprocessor/config/config.hpp</a>&gt;<br><br>#if <a href="variadics.html">BOOST_PP_IS_STANDARD()</a><br>#define BOOST_PP_LIMIT_MAG 512<br>#endif<br><br>#include &lt;boost/preprocessor/arithmetic.hpp&gt; // etc.<br></pre>
</div>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2020</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version
1.0.
(See accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,34 +1,45 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>BOOST_PP_LIMIT_FOR</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_LIMIT_FOR</b> macro defines the maximum number of <b>BOOST_PP_FOR</b> repetitions.
</div>
<h4>Usage</h4>
<div class="code">
<b>BOOST_PP_LIMIT_FOR</b>
</div>
<h4>Remarks</h4>
<div>
This macro currently expands to <i>256</i>.
</div>
<h4>Requirements</h4>
<div>
<b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<head>
<meta http-equiv="content-type" content="text/html;
charset=windows-1252">
<title>BOOST_PP_LIMIT_FOR</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIMIT_FOR</b> macro
defines the maximum number of <b>BOOST_PP_FOR</b> repetitions. </div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_LIMIT_FOR</b> </div>
<h4>Remarks</h4>
<div>This macro expands by default to <i>256</i>. For a C++
standard conforming preprocessor, the end-user can change this to
512 or 1024 by defining this macro to either value before
including any library headers, as long as the end-user also
defines the <a
href="file:///E:/Programming/VersionControl/modular-boost/libs/preprocessor/doc/ref/limit_mag.html">BOOST_PP_LIMIT_MAG</a>
macro to be equal to or greater than this value.</div>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<b>See also<br>
</b>
<ul>
<li><a href="../topics/limitations.html">Limitations</a></li>
<li><a href="../ref/is_standard.html">BOOST_PP_IS_STANDARD</a><br>
</li>
</ul>
<br>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a
href="http://www.housemarque.com" target="_top">Housemarque Oy</a>
2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version
1.0. (See accompanying file <a
href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,34 +1,46 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>BOOST_PP_LIMIT_ITERATION</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_LIMIT_ITERATION</b> macro defines the maximum number of <i>local</i> and <i>file</i> iterations.
</div>
<h4>Usage</h4>
<div class="code">
<b>BOOST_PP_LIMIT_ITERATION</b>
</div>
<h4>Remarks</h4>
<div>
This macro currently expands to <i>256</i>.
</div>
<h4>Requirements</h4>
<div>
<b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<head>
<meta http-equiv="content-type" content="text/html;
charset=windows-1252">
<title>BOOST_PP_LIMIT_ITERATION</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIMIT_ITERATION</b>
macro defines the maximum number of <i>local</i> and <i>file</i>
iterations. </div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_LIMIT_ITERATION</b> </div>
<h4>Remarks</h4>
<div> This macro expands by default to <i>256</i>. For a C++
standard conforming preprocessor, the end-user can change this to
512 or 1024 by defining this macro to either value before
including any library headers, as long as the end-user also
defines the <a href="../ref/limit_mag.html">BOOST_PP_LIMIT_MAG</a>
macro to be equal to or greater than this value. <br>
</div>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<b>See also<br>
</b>
<ul>
<li><a href="../topics/limitations.html">Limitations</a></li>
<li><a href="../ref/is_standard.html">BOOST_PP_IS_STANDARD</a><br>
</li>
</ul>
<br>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a
href="http://www.housemarque.com" target="_top">Housemarque Oy</a>
2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version
1.0. (See accompanying file <a
href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -13,7 +13,7 @@
</div>
<h4>Remarks</h4>
<div>
This macro currently expands to <i>5</i>.
This macro currently expands to <i>3</i>.
</div>
<h4>Requirements</h4>
<div>

View File

@ -1,34 +1,42 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>BOOST_PP_LIMIT_MAG</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_LIMIT_MAG</b> macro defines the maximum input and result magnitudes of arithmetic.
</div>
<h4>Usage</h4>
<div class="code">
<b>BOOST_PP_LIMIT_MAG</b>
</div>
<h4>Remarks</h4>
<div>
This macro currently expands to <i>256</i>.
</div>
<h4>Requirements</h4>
<div>
<b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<head>
<meta http-equiv="content-type" content="text/html;
charset=windows-1252">
<title>BOOST_PP_LIMIT_MAG</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIMIT_MAG</b> macro
defines the maximum input and result magnitudes of arithmetic. </div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_LIMIT_MAG</b> </div>
<h4>Remarks</h4>
<div> This macro expands by default to <i>256</i>. For a C++
standard conforming preprocessor, the end-user can change this to
512 or 1024 by defining this macro to either value before
including any library headers.</div>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<b>See also<br>
</b>
<ul>
<li><a href="../topics/limitations.html">Limitations</a></li>
<li><a href="../ref/is_standard.html">BOOST_PP_IS_STANDARD</a><br>
</li>
</ul>
<br>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a
href="http://www.housemarque.com" target="_top">Housemarque Oy</a>
2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version
1.0. (See accompanying file <a
href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,34 +1,62 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>BOOST_PP_LIMIT_REPEAT</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_LIMIT_REPEAT</b> macro defines the maximum number of repetitions supported by each <b>BOOST_PP_REPEAT</b> dimension.
</div>
<h4>Usage</h4>
<div class="code">
<b>BOOST_PP_LIMIT_REPEAT</b>
</div>
<h4>Remarks</h4>
<div>
This macro current expands to <i>256</i>.
</div>
<h4>Requirements</h4>
<div>
<b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<head>
<meta content="text/html; charset=windows-1252"
http-equiv="content-type">
<title>BOOST_PP_LIMIT_REPEAT</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIMIT_REPEAT</b>
macro defines the maximum number of repetitions supported by each
<b>BOOST_PP_REPEAT</b> dimension. </div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_LIMIT_REPEAT</b> </div>
<h4>Remarks</h4>
<div>This macro expands by default to <i>256</i>. For a C++
standard conforming preprocessor, the end-user can change this to
512 or 1024 by defining this macro to either value before
including any library headers, as long as the end-user also
defines the <a
href="file:///E:/Programming/VersionControl/modular-boost/libs/preprocessor/doc/ref/limit_mag.html">BOOST_PP_LIMIT_MAG</a>
macro to be equal to or greater than this value. <br>
<br>
NOTE: for the current latest versions of default preprocessor for
Microsoft's VC++ compiler there is a nested macro limit of 256.
This means in actuality that the number of repetitions using VC++
is actually less than 256 depending on the repetition macro being
used. For the BOOST_PP_REPEAT macro this limit appears to be 252
while for the BOOST_PP_ENUM... series of macros this limit appears
to be around 230, before the VC++ compiler gives a "C1009:
compiler limit : macros nested too deeply" error. This is a
compiler limitation of VC++ which may vary depending on the
specific repetition macro being used, and therefore is not a
problem the preprocessor library can solve. This limitation of the
default preprocessor for VC++ does not exist for the new standard
conforming preprocessor for VC++ in Visual Studio 2019 invoked
with the<code> /Zc:preprocessor</code> switch.<br>
</div>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<b>See also<br>
</b>
<ul>
<li><a href="../topics/limitations.html">Limitations</a></li>
<li><a href="../ref/is_standard.html">BOOST_PP_IS_STANDARD</a><br>
</li>
</ul>
<br>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a
href="http://www.housemarque.com" target="_top">Housemarque Oy</a>
2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version
1.0. (See accompanying file <a
href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,41 +1,44 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>BOOST_PP_LIMIT_SEQ</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_LIMIT_SEQ</b> macro defines the maximum <i>seq</i> size
supported by the library.
</div>
<h4>
Usage
</h4>
<div class="code">
<b>BOOST_PP_LIMIT_SEQ</b>
</div>
<h4>
Remarks
</h4>
<div>
This macro currently expands to <i>256</i>.
</div>
<h4>
Requirements
</h4>
<div>
<b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<head>
<meta http-equiv="content-type" content="text/html;
charset=windows-1252">
<title>BOOST_PP_LIMIT_SEQ</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIMIT_SEQ</b> macro
defines the maximum <i>seq</i> size supported by the library. </div>
<h4> Usage </h4>
<div class="code"> <b>BOOST_PP_LIMIT_SEQ</b> </div>
<h4> Remarks </h4>
<div>This macro expands by default to 256. For a C++ standard
conforming preprocessor, the macro actually expands to the value
of the <a href="../ref/limit_mag.html">BOOST_PP_LIMIT_MAG</a>
macro, but can be set to a lower value than BOOST_PP_LIMIT_MAG if
desired, but never to a higher value.<br>
</div>
<h4> Requirements </h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<b>See also<br>
</b>
<ul>
<li><a href="../topics/limitations.html">Limitations</a></li>
<li><a href="../ref/is_standard.html">BOOST_PP_IS_STANDARD</a><br>
</li>
</ul>
<br>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a
href="http://www.housemarque.com" target="_top">Housemarque Oy</a>
2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version
1.0. (See accompanying file <a
href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,34 +1,47 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>BOOST_PP_LIMIT_TUPLE</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_LIMIT_TUPLE</b> macro defines the maximum <i>tuple</i> size supported by the library.
</div>
<h4>Usage</h4>
<div class="code">
<b>BOOST_PP_LIMIT_TUPLE</b>
</div>
<h4>Remarks</h4>
<div>
This macro currently expands to <i>25</i>.
</div>
<h4>Requirements</h4>
<div>
<b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<head>
<meta http-equiv="content-type" content="text/html;
charset=windows-1252">
<title>BOOST_PP_LIMIT_TUPLE</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIMIT_TUPLE</b>
macro defines the maximum <i>tuple/array</i> size supported by
the library. </div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_LIMIT_TUPLE</b> </div>
<h4>Remarks</h4>
<div> This macro expands by default to <i>64</i>. For a C++
standard conforming preprocessor, the end-user can change this to
128 or 256 by defining this macro to either value before including
any library headers. If the end-user changes the value of the
macro the <a href="../ref/limit_variadic.html">BOOST_PP_LIMIT_VARIADIC</a>
macro is changed to the same value unless the end-user has changed
BOOST_PP_LIMIT_VARIADIC to a higher value.<br>
</div>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<b>See also<br>
</b>
<ul>
<li><a href="../topics/limitations.html">Limitations</a></li>
<li><a href="../ref/is_standard.html">BOOST_PP_IS_STANDARD</a><br>
</li>
</ul>
<br>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a
href="http://www.housemarque.com" target="_top">Housemarque Oy</a>
2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version
1.0. (See accompanying file <a
href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,43 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="content-type" content="text/html;
charset=windows-1252">
<title>BOOST_PP_LIMIT_VARIADIC</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIMIT_VARIADIC</b>
macro defines the maximum <i>variadic data</i>
size&nbsp;supported by the library. </div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_LIMIT_VARIADIC</b> </div>
<h4>Remarks</h4>
<div>This macro expands by default to <i>64</i>. For a C++ standard
conforming preprocessor, the end-user can change this to 128 or
256 by defining this macro to either value before including any
library headers. This value can never be less than the value of <a
href="../ref/limit_tuple.html">BOOST_PP_LIMIT_TUPLE</a>.<br>
</div>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<b>See also<br>
</b>
<ul>
<li><a href="../topics/limitations.html">Limitations</a></li>
<li><a href="../ref/is_standard.html">BOOST_PP_IS_STANDARD</a><br>
</li>
</ul>
<br>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2011</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version
1.0. (See accompanying file <a
href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,34 +1,35 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>BOOST_PP_LIMIT_WHILE</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_LIMIT_WHILE</b> macro defines the maximum number of <b>BOOST_PP_WHILE</b> iterations.
</div>
<h4>Usage</h4>
<div class="code">
<b>BOOST_PP_LIMIT_WHILE</b>
</div>
<h4>Remarks</h4>
<div>
This macro currently expands to <i>256</i>.
</div>
<h4>Requirements</h4>
<div>
<b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<head>
<meta http-equiv="content-type" content="text/html; charset=windows-1252">
<title>BOOST_PP_LIMIT_WHILE</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIMIT_WHILE</b>
macro defines the maximum number of <b>BOOST_PP_WHILE</b>
iterations. </div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_LIMIT_WHILE</b> </div>
<h4>Remarks</h4>
<div>This macro expands by default to <i>256</i>. The macro
actually expands to the value of the <a
href="file:///E:/Programming/VersionControl/modular-boost/libs/preprocessor/doc/ref/limit_mag.html">BOOST_PP_LIMIT_MAG</a>
macro and can not be changed.</div>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/config/limits.html">&lt;boost/preprocessor/config/limits.hpp&gt;</a>
</div>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a
href="http://www.housemarque.com" target="_top">Housemarque Oy</a>
2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version
1.0. (See accompanying file <a
href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,62 +1,62 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>BOOST_PP_LIST_ENUM</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_LIST_ENUM</b> macro converts a <i>list</i> to a comma-separated list.
</div>
<h4>Usage</h4>
<div class="code">
<b>BOOST_PP_LIST_ENUM</b>(<i>list</i>)
</div>
<h4>Arguments</h4>
<dl>
<dt>list</dt>
<dd>
The <i>list</i> to be converted.
</dd>
</dl>
<h4>Remarks</h4>
<div>
If <i>list</i> is, for example, (<i>a</i>, (<i>b</i>, (<i>c</i>, <b>BOOST_PP_NIL</b>))),
this macro will produce:
<div>
<i>a</i>, <i>b</i>, <i>c</i>
</div>
</div>
<div>
Previously, this macro could not be used inside <b>BOOST_PP_FOR</b>.&nbsp;
There is no longer any such restriction.&nbsp;
It is more efficient, however, to use <b>BOOST_PP_LIST_ENUM_R</b> in such a situation.
</div>
<h4>See Also</h4>
<ul>
<li><a href="list_enum_r.html">BOOST_PP_LIST_ENUM_R</a></li>
</ul>
<h4>Requirements</h4>
<div>
<b>Header:</b> &nbsp;<a href="../headers/list/enum.html">&lt;boost/preprocessor/list/enum.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div><pre>
#include &lt;<a href="../headers/list/enum.html">boost/preprocessor/list/enum.hpp</a>&gt;
<head>
<meta http-equiv="content-type" content="text/html; charset=windows-1252">
<title>BOOST_PP_LIST_ENUM</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIST_ENUM</b> macro
converts a <i>list</i> to a comma-separated list. </div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_LIST_ENUM</b>(<i>list</i>) </div>
<h4>Arguments</h4>
<dl>
<dt>list</dt>
<dd> The <i>list</i> to be converted. </dd>
</dl>
<h4>Remarks</h4>
<div> If <i>list</i> is, for example, (<i>a</i>, (<i>b</i>, (<i>c</i>,
<b>BOOST_PP_NIL</b>))), this macro will produce:
<div> <i>a</i>, <i>b</i>, <i>c</i> </div>
</div>
<div> Previously, this macro could not be used inside <b>BOOST_PP_FOR</b>.&nbsp;
There is no longer any such restriction.&nbsp; It is more
efficient, however, to use <b>BOOST_PP_LIST_ENUM_R</b> in such a
situation.<br>
<br>
In <a
href="file:///E:/Programming/VersionControl/modular-boost/libs/preprocessor/doc/topics/variadic_macros.html#C20_Support_For_Variadic_Macros">C++
20</a> mode if the list is empty the resulting <i>variadic</i>
<i>data</i> will be empty.</div>
<h4>See Also</h4>
<ul>
<li><a href="list_enum_r.html">BOOST_PP_LIST_ENUM_R</a></li>
</ul>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/list/enum.html">&lt;boost/preprocessor/list/enum.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div>
<pre>#include &lt;<a href="../headers/list/enum.html">boost/preprocessor/list/enum.hpp</a>&gt;
#define LIST (w, (x, (y, (z, <a href="nil.html">BOOST_PP_NIL</a>))))
<a href="list_enum.html">BOOST_PP_LIST_ENUM</a>(LIST) // expands to w, x, y, z
</pre></div>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</pre>
</div>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a
href="http://www.housemarque.com" target="_top">Housemarque Oy</a>
2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version
1.0. (See accompanying file <a
href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -31,6 +31,12 @@
<i>a</i>, <i>b</i>, <i>c</i>
</div>
</div>
<div>
In <a
href="file:///E:/Programming/VersionControl/modular-boost/libs/preprocessor/doc/topics/variadic_macros.html#C20_Support_For_Variadic_Macros">C++
20</a> mode if the list is empty the resulting <i>variadic</i>
<i>data</i> will be empty.
</div>
<h4>See Also</h4>
<ul>
<li><a href="list_enum.html">BOOST_PP_LIST_ENUM</a></li>

View File

@ -0,0 +1,47 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_LIST_TO_ARRAY</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIST_TO_ARRAY</b> macro
converts a <i>list</i> to an <i>array</i>. </div>
<h4> Usage </h4>
<div class="code"> <b>BOOST_PP_LIST_TO_ARRAY</b>(<i>list</i>) </div>
<h4> Arguments </h4>
<dl>
<dt>list</dt>
<dd> The <i>list</i> to be converted. <br>
</dd>
</dl>
<h4>Remarks</h4>
<div> This macro uses <b>BOOST_PP_WHILE</b>. Within <b>BOOST_PP_WHILE</b>,
it is more efficient to use <b>BOOST_PP_LIST_TO_ARRAY_D</b>.<br>
<br>
If the <i>list</i> to be converted is empty, as represented by
'BOOST_PP_NIL', the resulting <i>array</i> is empty, as represented by '( 0, ()
)'.</div>
<h4>See Also</h4>
<ul>
<li><a href="list_to_array_d.html">BOOST_PP_LIST_TO_ARRAY_D</a></li>
</ul>
<h4> Requirements </h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/list/to_array.html">&lt;boost/preprocessor/list/to_array.hpp&gt;</a>
</div>
<h4> Sample Code </h4>
<div>
<pre>#include &lt;<a href="../headers/list/to_array.html">boost/preprocessor/list/to_array.hpp</a>&gt;<br><br>#define LIST (a, (b, (c, <a
href="nil.html">BOOST_PP_NIL</a>)))<br><br><a href="list_to_array.html">BOOST_PP_LIST_TO_ARRAY</a>(LIST) // expands to (3, (a, b, c))</pre>
</div>
<hr size="1">
<div style="margin-left: 0px;"> <i></i><i>© Copyright Edward Diener 2011</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,42 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_LIST_TO_ARRAY_D</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIST_TO_ARRAY_D</b> macro
converts a <i>list</i> to an <i>array</i>. It reenters <b>BOOST_PP_WHILE</b>
with maximum efficiency. </div>
<h4> Usage </h4>
<div class="code"> <b>BOOST_PP_LIST_TO_ARRAY_D</b>(<i>d</i>, <i>list</i>)
</div>
<h4> Arguments </h4>
<dl>
<dt>d</dt>
<dd>The next available <b>BOOST_PP_WHILE</b> iteration.</dd>
<dt>list</dt>
<dd> The <i>list</i> to be converted. </dd>
</dl>
<h4>Remarks</h4>
<p>&nbsp;&nbsp;&nbsp; If the <i>list</i> to be converted is empty, as
represented by 'BOOST_PP_NIL', the resulting <i>array</i> is empty, as
represented by '( 0, () )'. </p>
<h4>See Also</h4>
<h4>See Also</h4>
<ul>
<li><a href="list_to_array_d.html">BOOST_PP_LIST_TO_ARRAY</a></li>
</ul>
<h4> Requirements </h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/list/to_array.html">&lt;boost/preprocessor/list/to_array.hpp&gt;</a>
</div>
<hr size="1">
<div style="margin-left: 0px;"> <i></i><i>© Copyright Edward Diener 2011</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

44
doc/ref/list_to_seq.html Normal file
View File

@ -0,0 +1,44 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_LIST_TO_SEQ</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIST_TO_SEQ</b> macro
converts a <i>list</i> to a <i>seq</i>. </div>
<h4> Usage </h4>
<div class="code"> <b>BOOST_PP_LIST_TO_SEQ</b>(<i>list</i>) </div>
<h4> Arguments </h4>
<dl>
<dt>list</dt>
<dd> The <i>list</i> to be converted. </dd>
</dl>
<h4>Remarks</h4>
<div> This macro uses <b>BOOST_PP_FOR</b>. Within <b>BOOST_PP_FOR</b>, it
is more efficient to use <b>BOOST_PP_LIST_TO_SEQ_R</b>.<br>
<br>
If the <i>list</i> to be converted is empty, as represented by
'BOOST_PP_NIL', the resulting <i>seq</i> is undefined since a <i>seq</i>
cannot be empty.</div>
<h4>See Also</h4>
<ul>
<li><a href="list_to_seq_r.html">BOOST_PP_LIST_TO_SEQ_R</a></li>
</ul>
<h4> Requirements </h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/list/to_seq.html">&lt;boost/preprocessor/list/to_seq.hpp&gt;</a>
</div>
<h4> Sample Code </h4>
<div>
<pre>#include &lt;<a href="../headers/list/to_seq.html">boost/preprocessor/list/to_seq.hpp</a>&gt;<br><br><a
href="list_to_seq.html">BOOST_PP_LIST_TO_SEQ</a>((a, (b, (c, <a href="nil.html">BOOST_PP_NIL</a>)))) // expands to (a)(b)(c)</pre>
</div>
<hr size="1">
<div style="margin-left: 0px;"> <i>© Copyright Edward Diener 2011</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,39 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_LIST_TO_SEQ_R</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIST_TO_SEQ_R</b> macro
converts a <i>list</i> to a <i>seq</i>. It reenters <b>BOOST_PP_FOR</b>
with maximum efficiency. </div>
<h4> Usage </h4>
<div class="code"> <b>BOOST_PP_LIST_TO_SEQ_R</b>(<i>r</i>, <i>list</i>) </div>
<h4> Arguments </h4>
<dl>
<dt>d</dt>
<dd>The next available <b>BOOST_PP_FOR</b> repetition.</dd>
<dt>list</dt>
<dd> The <i>list</i> to be converted.</dd>
</dl>
<h4>Remarks</h4>
<p>&nbsp;&nbsp;&nbsp; If the <i>list</i> to be converted is empty, as
represented by 'BOOST_PP_NIL', the resulting <i>seq</i> is undefined
since a <i>seq</i> cannot be empty.</p>
<h4>See Also</h4>
<ul>
<li><a href="list_to_seq_r.html">BOOST_PP_LIST_TO_SEQ</a></li>
</ul>
<h4> Requirements </h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/list/to_seq.html">&lt;boost/preprocessor/list/to_seq.hpp&gt;</a>
</div>
<hr size="1">
<div style="margin-left: 0px;"> <i>© Copyright Edward Diener 2011</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,62 +1,55 @@
<html>
<head>
<title>BOOST_PP_LIST_TO_TUPLE</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_LIST_TO_TUPLE</b> macro converts a <i>list</i> to a <i>tuple</i>.
</div>
<h4>Usage</h4>
<div class="code">
<b>BOOST_PP_LIST_TO_TUPLE</b>(<i>list</i>)
</div>
<h4>Arguments</h4>
<dl>
<dt>list</dt>
<dd>
The <i>list</i> to be converted.
</dd>
</dl>
<h4>Remarks</h4>
<div>
If <i>list</i> is, for example, (<i>a</i>, (<i>b</i>, (<i>c</i>, <b>BOOST_PP_NIL</b>))),
this macro will produce:
<div>
(<i>a</i>, <i>b</i>, <i>c</i>)
</div>
</div>
<div>
Previously, this macro could not be used inside <b>BOOST_PP_FOR</b>.&nbsp;
There is no longer any such restriction.&nbsp;
It is more efficient, however, to use <b>BOOST_PP_LIST_TO_TUPLE_R</b> in such a situation.
</div>
<h4>See Also</h4>
<ul>
<li><a href="list_to_tuple_r.html">BOOST_PP_LIST_TO_TUPLE_R</a></li>
</ul>
<h4>Requirements</h4>
<div>
<b>Header:</b> &nbsp;<a href="../headers/list/to_tuple.html">&lt;boost/preprocessor/list/to_tuple.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div><pre>
#include &lt;<a href="../headers/list/to_tuple.html">boost/preprocessor/list/to_tuple.hpp</a>&gt;
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_LIST_TO_TUPLE</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIST_TO_TUPLE</b> macro
converts a <i>list</i> to a <i>tuple</i>. </div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_LIST_TO_TUPLE</b>(<i>list</i>) </div>
<h4>Arguments</h4>
<dl>
<dt>list</dt>
<dd> The <i>list</i> to be converted. </dd>
</dl>
<h4>Remarks</h4>
<div> If <i>list</i> is, for example, (<i>a</i>, (<i>b</i>, (<i>c</i>, <b>BOOST_PP_NIL</b>))),
this macro will produce:
<div> (<i>a</i>, <i>b</i>, <i>c</i>) </div>
</div>
<div> Previously, this macro could not be used inside <b>BOOST_PP_FOR</b>.&nbsp;
There is no longer any such restriction.&nbsp; It is more efficient,
however, to use <b>BOOST_PP_LIST_TO_TUPLE_R</b> in such a situation.<br>
<br>
If the <i>list</i> to be converted is empty, as represented by 'BOOST_PP_NIL',
the resulting <i>tuple</i> is undefined since a <i>tuple</i> cannot be
empty.</div>
<h4>See Also</h4>
<ul>
<li><a href="list_to_tuple_r.html">BOOST_PP_LIST_TO_TUPLE_R</a></li>
</ul>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/list/to_tuple.html">&lt;boost/preprocessor/list/to_tuple.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div>
<pre>#include &lt;<a href="../headers/list/to_tuple.html">boost/preprocessor/list/to_tuple.hpp</a>&gt;
#define LIST (w, (x, (y, (z, <a href="nil.html">BOOST_PP_NIL</a>))))
<a href="list_to_tuple.html">BOOST_PP_LIST_TO_TUPLE</a>(LIST) // expands to (w, x, y, z)
</pre></div>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a href="http://www.housemarque.com"
target="_top">Housemarque Oy</a> 2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,47 +1,42 @@
<html>
<head>
<title>BOOST_PP_LIST_TO_TUPLE_R</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_LIST_TO_TUPLE_R</b> macro converts a <i>list</i> to a <i>tuple</i>.&nbsp;
It reenters <b>BOOST_PP_FOR</b> with maximum efficiency.
</div>
<h4>Usage</h4>
<div class="code">
<b>BOOST_PP_LIST_TO_TUPLE_R</b>(<i>r</i>, <i>list</i>)
</div>
<h4>Arguments</h4>
<dl>
<dt>r</dt>
<dd>
The next available <b>BOOST_PP_FOR</b> repetition.
</dd>
<dt>list</dt>
<dd>
The <i>list</i> to be converted.
</dd>
</dl>
<h4>Remarks</h4>
<div>
If <i>list</i> is, for example, (<i>a</i>, (<i>b</i>, (<i>c</i>, <b>BOOST_PP_NIL</b>))),
this macro will produce:
<div>
(<i>a</i>, <i>b</i>, <i>c</i>)
</div>
</div>
<h4>See Also</h4>
<ul>
<li><a href="list_to_tuple.html">BOOST_PP_LIST_TO_TUPLE</a></li>
</ul>
<h4>Requirements</h4>
<div>
<b>Header:</b> &nbsp;<a href="../headers/list/to_tuple.html">&lt;boost/preprocessor/list/to_tuple.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div><pre>
#include &lt;<a href="../headers/list/adt.html">boost/preprocessor/list/adt.hpp</a>&gt;
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_LIST_TO_TUPLE_R</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_LIST_TO_TUPLE_R</b> macro
converts a <i>list</i> to a <i>tuple</i>.&nbsp; It reenters <b>BOOST_PP_FOR</b>
with maximum efficiency. </div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_LIST_TO_TUPLE_R</b>(<i>r</i>, <i>list</i>)
</div>
<h4>Arguments</h4>
<dl>
<dt>r</dt>
<dd> The next available <b>BOOST_PP_FOR</b> repetition. </dd>
<dt>list</dt>
<dd> The <i>list</i> to be converted. </dd>
</dl>
<h4>Remarks</h4>
<p>&nbsp;&nbsp; If <i>list</i> is, for example, (<i>a</i>, (<i>b</i>, (<i>c</i>,
<b>BOOST_PP_NIL</b>))), this macro will produce: </p>
<div>
<div> (<i>a</i>, <i>b</i>, <i>c</i>)&nbsp;&nbsp; </div>
</div>
<h4><span style="font-weight: normal;">&nbsp;&nbsp; If the <i>list</i> to
be converted is empty, as represented by 'BOOST_PP_NIL', the resulting <i>tuple</i>
is undefined since a <i>tuple</i> cannot be empty. </span></h4>
<h4>See Also</h4>
<ul>
<li><a href="list_to_tuple.html">BOOST_PP_LIST_TO_TUPLE</a></li>
</ul>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/list/to_tuple.html">&lt;boost/preprocessor/list/to_tuple.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div>
<pre>#include &lt;<a href="../headers/list/adt.html">boost/preprocessor/list/adt.hpp</a>&gt;
#include &lt;<a href="../headers/list/to_tuple.html">boost/preprocessor/list/to_tuple.hpp</a>&gt;
#include &lt;<a href="../headers/repetition/for.html">boost/preprocessor/repetition/for.hpp</a>&gt;
@ -54,16 +49,14 @@
<a href="for.html">BOOST_PP_FOR</a>(LIST, PRED, OP, MACRO)
// expands to (x, y, z) (y, z) (z)
</pre></div>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a href="http://www.housemarque.com"
target="_top">Housemarque Oy</a> 2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -34,7 +34,7 @@
It is more efficient, however, to use <b>BOOST_PP_MUL_D</b> in such a situation.
</div>
<div>
This macro is the most efficient when <i>x</i> is less than or equal to <i>y</i>.&nbsp;
This macro is the most efficient when <i>x</i> is greater than or equal to <i>y</i>.&nbsp;
However, the efficiency gain is not worth actually comparing the two arguments prior to invocation.&nbsp;
In other words, <i>x</i> should be the value that is <i>most likely</i> to be the largest of the two operands.
</div>

View File

@ -34,7 +34,7 @@
If the product of <i>x</i> and <i>y</i> is greater than <b>BOOST_PP_LIMIT_MAG</b>, the result is saturated to <b>BOOST_PP_LIMIT_MAG</b>.
</div>
<div>
This macro is the most efficient when <i>x</i> is less than or equal to <i>y</i>.&nbsp;
This macro is the most efficient when <i>x</i> is greater than or equal to <i>y</i>.&nbsp;
However, the efficiency gain is not worth actually comparing the two arguments prior to invocation.&nbsp;
In other words, <i>x</i> should be the value that is <i>most likely</i> to be the largest of the two operands.
</div>

64
doc/ref/overload.html Normal file
View File

@ -0,0 +1,64 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta content="text/html; charset=windows-1252"
http-equiv="content-type">
<title>BOOST_PP_OVERLOAD</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_OVERLOAD</b>
variadic macro expands to the name of a non-variadic macro having
a given number of parameters.<br>
</div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_OVERLOAD</b>(<i>prefix</i>,...) <a
href="../topics/variadic_macros.html#VNotation" target="_self"><sup>(v)</sup></a><br>
</div>
<h4>Arguments</h4>
<dl>
<dt>prefix<br>
</dt>
<dd> The prefix of the non-variadic macro name. </dd>
<dt>...<br>
</dt>
<dd><i> Variadic data</i>. The number of variadic data elements,
as determined by BOOST_PP_VARIADIC_SIZE, is appended to the
prefix to form the output non-variadic macro name.<br>
</dd>
</dl>
<h4>Remarks</h4>
<div> This macro creates a macro name which depends on the number of
elements of variadic data. It should be used in the form of <br>
BOOST_PP_OVERLOAD(MACRO_NAME_,__VA_ARGS__)(__VA_ARGS__) in order
to call a non-variadic macro taking a given number of variadic
data elements as non-variadic arguments. In this way one can
invoke a variadic macro with a variable number of parameters which
calls one of a series of non-variadic macros doing very similar
things.<br>
<br>
In <a
href="file:///E:/Programming/VersionControl/modular-boost/libs/preprocessor/doc/topics/variadic_macros.html#C20_Support_For_Variadic_Macros">C++
20</a> mode the <i>variadic</i> <i>data</i> can be empty and
the given number of parameters will be 0.<br>
</div>
<b>Requirements</b>
<div> <b>Header:</b> &nbsp;<a
href="../headers/facilities/overload.html">&lt;boost/preprocessor/facilities/overload.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div>
<pre>#include &lt;<a href="../headers/facilities/overload.html">boost/preprocessor/facilities/overload.hpp</a>&gt;<br>#include &lt;<a href="../headers/cat.html">boost/preprocessor/cat.hpp</a>&gt;<br>#include &lt;<a href="../headers/facilities/empty.html">boost/preprocessor/facilities/empty.hpp</a>&gt;<br>#include &lt;<a href="../headers/arithmetic/add.html">boost/preprocessor/arithmetic/add.hpp</a>&gt;<br><br>#define MACRO_1(number) MACRO_2(number,10)<br>#define MACRO_2(number1,number2) <a href="add.html">BOOST_PP_ADD</a>(number1,number2)<br><br>#if !BOOST_PP_VARIADICS_MSVC<br><br>#define MACRO_ADD_NUMBERS(...) <a href="overload.html">BOOST_PP_OVERLOAD</a>(MACRO_,__VA_ARGS__)(__VA_ARGS__)<br><br>#else<br><br>// or for Visual C++'s default preprocessor<br><br>#define MACRO_ADD_NUMBERS(...) \<br> <a href="cat.html">BOOST_PP_CAT</a>(<a href="overload.html">BOOST_PP_OVERLOAD</a>(MACRO_,__VA_ARGS__)(__VA_ARGS__),<a href="empty.html">BOOST_PP_EMPTY</a>())<br><br>#endif<br><br>MACRO_ADD_NUMBERS(5) // output is 15<br>MACRO_ADD_NUMBERS(3,6) // output is 9</pre>
</div>
<hr size="1">
<div style="margin-left: 0px;"> <i></i><i><EFBFBD> Copyright Edward Diener
2011,2013,2016</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version
1.0.
(See accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,44 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_REMOVE_PARENS</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_REMOVE_PAREN</b>S macro
removes the beginning parenthesis, if it exists, from the input data and
expands to the result</div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_REMOVE_PARENS</b>(param) <a href="../topics/variadic_macros.html#VNotation"
target="_self"><sup>(v)</sup></a></div>
<h4>Arguments&nbsp;&nbsp;&nbsp;&nbsp;<span style="font-weight: normal;"></span></h4>
<h4><span style="font-weight: normal;">&nbsp;&nbsp;&nbsp; param</span>&nbsp;&nbsp;
<span style="font-weight: normal;">&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;
The input data.</span></h4>
<h4>Remarks</h4>
<div> If the input begins with a parenthesis, with any data within that
parenthesis, the macro removes the parenthesis and expands to the result.
If the input does not begin with a parenthesis the macro expands to the
input.<br>
</div>
<h4>See Also</h4>
<ul>
<li><a href="is_begin_parens.html">BOOST_PP_IS_BEGIN_PARENS</a></li>
</ul>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/punctuation/remove_parens.html">&lt;boost/preprocessor/punctuation/remove_parens.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div>
<pre>#include &lt;<a href="../headers/punctuation/remove_parens.html">boost/preprocessor/punctuation/remove_parens.hpp</a>&gt;<br><br>#define DATA data<br>#define DATAP ( data ) more_data<br><br>BOOST_PP_REMOVE_PARENS(DATA) // expands to 'data'
BOOST_PP_REMOVE_PARENS(DATAP) // expands to 'data more_data'<br>
</pre></div>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2014</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,67 +1,59 @@
<html>
<head>
<title>BOOST_PP_REPEAT_z</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_REPEAT_<i>z</i></b> macro represents a reentry into the <b>BOOST_PP_REPEAT</b> repetition construct.
</div>
<h4>Usage</h4>
<div class="code">
<b>BOOST_PP_REPEAT_</b> ## <i>z</i>(<i>count</i>, <i>macro</i>, <i>data</i>)
</div>
<h4>Arguments</h4>
<dl>
<dt>z</dt>
<dd>
The next available <b>BOOST_PP_REPEAT</b> dimension.
</dd>
<dt>count</dt>
<dd>
The number of repetitious calls to <i>macro</i>.&nbsp;
Valid values range from <i>0</i> to <b>BOOST_PP_LIMIT_REPEAT</b>.
</dd>
<dt>macro</dt>
<dd>
A ternary operation of the form <i>macro</i>(<i>z</i>, <i>n</i>, <i>data</i>).&nbsp;
This macro is expanded by <b>BOOST_PP_REPEAT</b> with the next available repetition depth,
the current repetition number, and the auxiliary <i>data</i> argument.&nbsp;
</dd>
<dt>data</dt>
<dd>
Auxiliary data passed to <i>macro</i>.
</dd>
</dl>
<h4>Remarks</h4>
<div>
This macro expands to the sequence:
<div>
<i>macro</i>(<i>z</i>, <i>0</i>, <i>data</i>) <i>macro</i>(<i>z</i>, <i>1</i>, <i>data</i>) ... <i>macro</i>(<i>z</i>, <i>count</i> - <i>1</i>, <i>data</i>)
</div>
</div>
<div>
At certain times, it may be necessary to perform the concatenation with <b>BOOST_PP_CAT</b> rather than the preprocessor token-pasting operator.&nbsp;
This happens when the <i>z</i> value is a macro invocation itself.&nbsp;
It needs a delay to allow it to expand.&nbsp;
The syntax in such a scenario becomes:
<div>
<b>BOOST_PP_CAT</b>(<b>BOOST_PP_REPEAT_</b>, <i>z</i>)(<i>count</i>, <i>macro</i>, <i>data</i>)
</div>
</div>
<h4>See Also</h4>
<ul>
<li><a href="cat.html">BOOST_PP_CAT</a></li>
<li><a href="limit_repeat.html">BOOST_PP_LIMIT_REPEAT</a></li>
<li><a href="repeat.html">BOOST_PP_REPEAT</a></li>
</ul>
<h4>Requirements</h4>
<div>
<b>Header:</b> &nbsp;<a href="../headers/repetition/repeat.html">&lt;boost/preprocessor/repetition/repeat.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div><pre>
#include &lt;<a href="../headers/arithmetic/inc.html">boost/preprocessor/arithmetic/inc.hpp</a>&gt;
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_REPEAT_z</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;"> The <b>BOOST_PP_REPEAT_<i>z</i></b> macro
represents a reentry into the <b>BOOST_PP_REPEAT</b> repetition
construct. </div>
<h4>Usage</h4>
<div class="code"> <b>BOOST_PP_REPEAT_</b> ## <i>z</i>(<i>count</i>, <i>macro</i>,
<i>data</i>) </div>
<h4>Arguments</h4>
<dl>
<dt>z</dt>
<dd> The next available <b>BOOST_PP_REPEAT</b> dimension. </dd>
<dt>count</dt>
<dd> The number of repetitious calls to <i>macro</i>.&nbsp; Valid values
range from <i>0</i> to <b>BOOST_PP_LIMIT_REPEAT</b>. </dd>
<dt>macro</dt>
<dd> A ternary operation of the form <i>macro</i>(<i>z</i>, <i>n</i>, <i>data</i>).&nbsp;
This macro is expanded by <b>BOOST_PP_REPEAT</b> with the next
available repetition depth, the current repetition number, and the
auxiliary <i>data</i> argument.&nbsp; </dd>
<dt>data</dt>
<dd> Auxiliary data passed to <i>macro</i>. </dd>
</dl>
<h4>Remarks</h4>
<div> This macro expands to the sequence:
<div> <i>macro</i>(<i>z</i>, <i>0</i>, <i>data</i>) <i>macro</i>(<i>z</i>,
<i>1</i>, <i>data</i>) ... <i>macro</i>(<i>z</i>, <i>count</i> - <i>1</i>,
<i>data</i>) </div>
</div>
<div> At certain times, it may be necessary to perform the concatenation
with <b>BOOST_PP_CAT</b> rather than the preprocessor token-pasting
operator.&nbsp; This happens when the <i>z</i> value is a macro
invocation itself.&nbsp; It needs a delay to allow it to expand.&nbsp; The
syntax in such a scenario becomes:
<div> <b>BOOST_PP_CAT</b>(<b>BOOST_PP_REPEAT_</b>, <i>z</i>)(<i>count</i>,
<i>macro</i>, <i>data</i>) </div>
</div>
<h4>See Also</h4>
<ul>
<li><a href="cat.html">BOOST_PP_CAT</a></li>
<li><a href="limit_repeat.html">BOOST_PP_LIMIT_REPEAT</a></li>
<li><a href="repeat.html">BOOST_PP_REPEAT</a></li>
<li><a href="repeat_z_macros.html"><span style="color: gray;">Macros with
Z re-entrancy forms</span></a></li>
</ul>
<h4>Requirements</h4>
<div> <b>Header:</b> &nbsp;<a href="../headers/repetition/repeat.html">&lt;boost/preprocessor/repetition/repeat.hpp&gt;</a>
</div>
<h4>Sample Code</h4>
<div>
<pre>#include &lt;<a href="../headers/arithmetic/inc.html">boost/preprocessor/arithmetic/inc.hpp</a>&gt;
#include &lt;<a href="../headers/punctuation/comma_if.html">boost/preprocessor/punctuation/comma_if.hpp</a>&gt;
#include &lt;<a href="../headers/repetition/repeat.html">boost/preprocessor/repetition/repeat.hpp</a>&gt;
@ -85,16 +77,16 @@
template&lt;class, class, class&gt; class T2
*/
</pre></div>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright <a href="http://www.housemarque.com"
target="_top">Housemarque Oy</a> 2002</i> <br>
<i><EFBFBD> Copyright Paul Mensonides 2002<br>
</i><i><EFBFBD> Copyright Edward Diener 2014</i><br>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -0,0 +1,45 @@
<html>
<head>
<meta content="text/html; charset=windows-1252" http-equiv="content-type">
<title>BOOST_PP_REPEAT_z_macros</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>This is a list, based on functionality, of the macros which have an
alternate <b>_z<i></i></b> name, representing a reentry into the <b>BOOST_PP_REPEAT</b>
looping construct:<br>
<br>
array<br>
<ul>
<li><a href="array_pop_back_z.html">BOOST_PP_ARRAY_POP_BACK_Z</a></li>
<li><a href="array_pop_front_z.html">BOOST_PP_ARRAY_POP_FRONT_Z</a></li>
</ul>
repetition<br>
<ul>
<li><a href="deduce_z.html">BOOST_PP_DEDUCE_Z</a></li>
<li><a href="enum_binary_params_z.html">BOOST_PP_ENUM_BINARY_PARAMS_Z</a></li>
<li><a href="enum_params_z.html">BOOST_PP_ENUM_PARAMS_Z</a></li>
<li><a href="esbpz.html">BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_Z</a></li>
<li><a href="enum_shifted_params_z.html">BOOST_PP_ENUM_SHIFTED_PARAMS_Z</a></li>
<li><a href="enum_shifted_z.html">BOOST_PP_ENUM_SHIFTED_<i>z</i></a></li>
<li><a href="etbpz.html">BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z</a></li>
<li><a href="enum_trailing_params_z.html">BOOST_PP_ENUM_TRAILING_PARAMS_Z</a></li>
<li><a href="enum_trailing_z.html">BOOST_PP_ENUM_TRAILING_<i>z</i></a></li>
<li><a href="enum_z.html">BOOST_PP_ENUM_<i>z</i></a></li>
<li><a href="repeat_from_to_d_z.html">BOOST_PP_REPEAT_FROM_TO_D_<i>z</i></a></li>
<li><a href="repeat_from_to_z.html">BOOST_PP_REPEAT_FROM_TO_<i>z</i></a></li>
</ul>
base<br>
<ul>
<li><a href="repeat_z.html">BOOST_PP_REPEAT_<i>z</i></a></li>
</ul>
<br>
<pre></pre>
<hr size="1">
<div style="margin-left: 0px;"> <i><EFBFBD> Copyright Edward Diener 2014</i> </div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</html>

View File

@ -1,17 +1,17 @@
<html>
<head>
<title>BOOST_PP_SEQ_CAT</title>
<head>
<title>BOOST_PP_SEQ_CAT</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_SEQ_CAT</b> macro concatenates all elements in a <i>seq</i>.
</div>
<h4>
Usage
</h4>
<div class="code">
<b>BOOST_PP_SEQ_CAT</b>(<i>list</i>)
<b>BOOST_PP_SEQ_CAT</b>(<i>seq</i>)
</div>
<h4>
Arguments
@ -48,24 +48,17 @@
Sample Code
</h4>
<div>
<pre>
#include &lt;<a href="../headers/seq/cat.html">boost/preprocessor/seq/cat.hpp</a>&gt;
#define SEQ (a)(b)(c)
<a href="seq_cat.html">BOOST_PP_SEQ_CAT</a>(SEQ) // expands to abc
</pre>
<pre>#include &lt;<a href="../headers/seq/cat.html">boost/preprocessor/seq/cat.hpp</a>&gt;<br><br>#define SEQ (a)(b)(c)<br><br><a href="seq_cat.html">BOOST_PP_SEQ_CAT</a>(SEQ) // expands to abc<br></pre>
</div>
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
<br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</body>
</html>

View File

@ -1,10 +1,10 @@
<html>
<head>
<title>BOOST_PP_SEQ_CAT_S</title>
<head>
<title>BOOST_PP_SEQ_CAT_S</title>
<link rel="stylesheet" type="text/css" href="../styles.css">
</head>
<body>
<div style="margin-left: 0px;">
</head>
<body>
<div style="margin-left: 0px;">
The <b>BOOST_PP_SEQ_CAT_S</b> macro concatenates all elements in a <i>seq</i>.&nbsp;
It reenters <b>BOOST_PP_SEQ_FOLD_LEFT</b> with maximum efficiency.
</div>
@ -12,7 +12,7 @@
Usage
</h4>
<div class="code">
<b>BOOST_PP_SEQ_CAT_S</b>(<i>s</i>, <i>list</i>)
<b>BOOST_PP_SEQ_CAT_S</b>(<i>s</i>, <i>seq</i>)
</div>
<h4>
Arguments
@ -49,13 +49,12 @@
<hr size="1">
<div style="margin-left: 0px;">
<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
</br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
<br><i><EFBFBD> Copyright Paul Mensonides 2002</i>
</div>
<div style="margin-left: 0px;">
<p><small>Distributed under the Boost Software License, Version 1.0. (See
accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
</div>
</body>
</body>
</html>

Some files were not shown because too many files have changed in this diff Show More