From 41508fb114e731651ee86ce6275c8b1154a9c292 Mon Sep 17 00:00:00 2001 From: Anton Bachin Date: Fri, 5 Jun 2015 18:57:00 -0500 Subject: [PATCH] Eliminated underscored internal macro names. Also made a few documentation changes. --- README.md | 15 + doc/sitemap.xml | 10 - enum.h | 701 ++++++++++++++++++++++++------------------ script/make_macros.py | 66 ++-- 4 files changed, 452 insertions(+), 340 deletions(-) delete mode 100644 doc/sitemap.xml diff --git a/README.md b/README.md index 74cd18e..8b2d619 100644 --- a/README.md +++ b/README.md @@ -68,6 +68,21 @@ enums that are missing from standard C++. [performance]: http://aantron.github.io/better-enums/Performance.html +## Limitations + +The biggest current limitation is that the `ENUM` macro can't be used inside a +class or namespace. This seems difficult to remove, but I am looking into it. In +the meantime, there is a workaround with a `typedef` (or `using`): + +```cpp +ENUM(UniquePrefix_Color, uint8_t, Red, Green, Blue) + +struct triplet { + typedef UniquePrefix_Color Color; + Color r, g, b; +}; +``` + ## Contact Don't hesitate to contact me about features or bugs: diff --git a/doc/sitemap.xml b/doc/sitemap.xml deleted file mode 100644 index adb2747..0000000 --- a/doc/sitemap.xml +++ /dev/null @@ -1,10 +0,0 @@ - - - - http://aantron.github.io/better-enums - 1.0 - - - http://aantron.github.io/better-enums/api.html - - diff --git a/enum.h b/enum.h index 9b02855..7a5ebcb 100644 --- a/enum.h +++ b/enum.h @@ -3,8 +3,8 @@ #pragma once -#ifndef _BETTER_ENUMS_ENUM_H_ -#define _BETTER_ENUMS_ENUM_H_ +#ifndef BETTER_ENUMS__ENUM_H +#define BETTER_ENUMS__ENUM_H @@ -15,17 +15,17 @@ #ifdef BETTER_ENUMS_CONSTEXPR -# define _ENUM_HAVE_CONSTEXPR +# define BETTER_ENUMS__HAVE_CONSTEXPR #else # ifdef __GNUC__ # ifdef __clang__ # if __has_feature(cxx_constexpr) -# define _ENUM_HAVE_CONSTEXPR +# define BETTER_ENUMS__HAVE_CONSTEXPR # endif # else # if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) # if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L -# define _ENUM_HAVE_CONSTEXPR +# define BETTER_ENUMS__HAVE_CONSTEXPR # endif # endif # endif @@ -33,17 +33,25 @@ #endif #ifdef BETTER_ENUMS_NO_CONSTEXPR -# if defined(_ENUM_HAVE_CONSTEXPR) -# undef _ENUM_HAVE_CONSTEXPR +# if defined(BETTER_ENUMS__HAVE_CONSTEXPR) +# undef BETTER_ENUMS__HAVE_CONSTEXPR # endif #endif -#ifdef _ENUM_HAVE_CONSTEXPR -# define _ENUM_CONSTEXPR constexpr -# define _ENUM_NULLPTR nullptr +// GCC (and maybe clang) can be made to warn about using 0 or NULL when nullptr +// is available, so Better Enums tries to use nullptr. This passage uses +// availability of constexpr as a proxy for availability of nullptr, i.e. it +// assumes that nullptr is available when compiling on the right versions of gcc +// and clang with the right -std flag. This is actually slightly wrong, because +// nullptr is also available in Visual C++, but constexpr isn't. This +// imprecision doesn't matter, however, because VC++ doesn't have the warnings +// that make using nullptr necessary. +#ifdef BETTER_ENUMS__HAVE_CONSTEXPR +# define BETTER_ENUMS__CONSTEXPR constexpr +# define BETTER_ENUMS__NULLPTR nullptr #else -# define _ENUM_CONSTEXPR -# define _ENUM_NULLPTR NULL +# define BETTER_ENUMS__CONSTEXPR +# define BETTER_ENUMS__NULLPTR NULL #endif #ifndef __GNUC__ @@ -56,147 +64,218 @@ # include BETTER_ENUMS_MACRO_FILE #else -#define _ENUM_PP_MAP(macro, data, ...) \ - _ENUM_ID(_ENUM_A(_ENUM_PP_MAP_VAR_COUNT, _ENUM_PP_COUNT(__VA_ARGS__)) \ +#define BETTER_ENUMS__PP_MAP(macro, data, ...) \ + BETTER_ENUMS__ID( \ + BETTER_ENUMS__APPLY( \ + BETTER_ENUMS__PP_MAP_VAR_COUNT, \ + BETTER_ENUMS__PP_COUNT(__VA_ARGS__)) \ (macro, data, __VA_ARGS__)) -#define _ENUM_PP_MAP_VAR_COUNT(count) _ENUM_M ## count +#define BETTER_ENUMS__PP_MAP_VAR_COUNT(count) BETTER_ENUMS__M ## count -#define _ENUM_A(macro, ...) _ENUM_ID(macro(__VA_ARGS__)) +#define BETTER_ENUMS__APPLY(macro, ...) BETTER_ENUMS__ID(macro(__VA_ARGS__)) -#define _ENUM_ID(x) x +#define BETTER_ENUMS__ID(x) x -#define _ENUM_M1(m, d, x) m(d,0,x) -#define _ENUM_M2(m,d,x,...) m(d,1,x) _ENUM_ID(_ENUM_M1(m,d,__VA_ARGS__)) -#define _ENUM_M3(m,d,x,...) m(d,2,x) _ENUM_ID(_ENUM_M2(m,d,__VA_ARGS__)) -#define _ENUM_M4(m,d,x,...) m(d,3,x) _ENUM_ID(_ENUM_M3(m,d,__VA_ARGS__)) -#define _ENUM_M5(m,d,x,...) m(d,4,x) _ENUM_ID(_ENUM_M4(m,d,__VA_ARGS__)) -#define _ENUM_M6(m,d,x,...) m(d,5,x) _ENUM_ID(_ENUM_M5(m,d,__VA_ARGS__)) -#define _ENUM_M7(m,d,x,...) m(d,6,x) _ENUM_ID(_ENUM_M6(m,d,__VA_ARGS__)) -#define _ENUM_M8(m,d,x,...) m(d,7,x) _ENUM_ID(_ENUM_M7(m,d,__VA_ARGS__)) -#define _ENUM_M9(m,d,x,...) m(d,8,x) _ENUM_ID(_ENUM_M8(m,d,__VA_ARGS__)) -#define _ENUM_M10(m,d,x,...) m(d,9,x) _ENUM_ID(_ENUM_M9(m,d,__VA_ARGS__)) -#define _ENUM_M11(m,d,x,...) m(d,10,x) _ENUM_ID(_ENUM_M10(m,d,__VA_ARGS__)) -#define _ENUM_M12(m,d,x,...) m(d,11,x) _ENUM_ID(_ENUM_M11(m,d,__VA_ARGS__)) -#define _ENUM_M13(m,d,x,...) m(d,12,x) _ENUM_ID(_ENUM_M12(m,d,__VA_ARGS__)) -#define _ENUM_M14(m,d,x,...) m(d,13,x) _ENUM_ID(_ENUM_M13(m,d,__VA_ARGS__)) -#define _ENUM_M15(m,d,x,...) m(d,14,x) _ENUM_ID(_ENUM_M14(m,d,__VA_ARGS__)) -#define _ENUM_M16(m,d,x,...) m(d,15,x) _ENUM_ID(_ENUM_M15(m,d,__VA_ARGS__)) -#define _ENUM_M17(m,d,x,...) m(d,16,x) _ENUM_ID(_ENUM_M16(m,d,__VA_ARGS__)) -#define _ENUM_M18(m,d,x,...) m(d,17,x) _ENUM_ID(_ENUM_M17(m,d,__VA_ARGS__)) -#define _ENUM_M19(m,d,x,...) m(d,18,x) _ENUM_ID(_ENUM_M18(m,d,__VA_ARGS__)) -#define _ENUM_M20(m,d,x,...) m(d,19,x) _ENUM_ID(_ENUM_M19(m,d,__VA_ARGS__)) -#define _ENUM_M21(m,d,x,...) m(d,20,x) _ENUM_ID(_ENUM_M20(m,d,__VA_ARGS__)) -#define _ENUM_M22(m,d,x,...) m(d,21,x) _ENUM_ID(_ENUM_M21(m,d,__VA_ARGS__)) -#define _ENUM_M23(m,d,x,...) m(d,22,x) _ENUM_ID(_ENUM_M22(m,d,__VA_ARGS__)) -#define _ENUM_M24(m,d,x,...) m(d,23,x) _ENUM_ID(_ENUM_M23(m,d,__VA_ARGS__)) -#define _ENUM_M25(m,d,x,...) m(d,24,x) _ENUM_ID(_ENUM_M24(m,d,__VA_ARGS__)) -#define _ENUM_M26(m,d,x,...) m(d,25,x) _ENUM_ID(_ENUM_M25(m,d,__VA_ARGS__)) -#define _ENUM_M27(m,d,x,...) m(d,26,x) _ENUM_ID(_ENUM_M26(m,d,__VA_ARGS__)) -#define _ENUM_M28(m,d,x,...) m(d,27,x) _ENUM_ID(_ENUM_M27(m,d,__VA_ARGS__)) -#define _ENUM_M29(m,d,x,...) m(d,28,x) _ENUM_ID(_ENUM_M28(m,d,__VA_ARGS__)) -#define _ENUM_M30(m,d,x,...) m(d,29,x) _ENUM_ID(_ENUM_M29(m,d,__VA_ARGS__)) -#define _ENUM_M31(m,d,x,...) m(d,30,x) _ENUM_ID(_ENUM_M30(m,d,__VA_ARGS__)) -#define _ENUM_M32(m,d,x,...) m(d,31,x) _ENUM_ID(_ENUM_M31(m,d,__VA_ARGS__)) -#define _ENUM_M33(m,d,x,...) m(d,32,x) _ENUM_ID(_ENUM_M32(m,d,__VA_ARGS__)) -#define _ENUM_M34(m,d,x,...) m(d,33,x) _ENUM_ID(_ENUM_M33(m,d,__VA_ARGS__)) -#define _ENUM_M35(m,d,x,...) m(d,34,x) _ENUM_ID(_ENUM_M34(m,d,__VA_ARGS__)) -#define _ENUM_M36(m,d,x,...) m(d,35,x) _ENUM_ID(_ENUM_M35(m,d,__VA_ARGS__)) -#define _ENUM_M37(m,d,x,...) m(d,36,x) _ENUM_ID(_ENUM_M36(m,d,__VA_ARGS__)) -#define _ENUM_M38(m,d,x,...) m(d,37,x) _ENUM_ID(_ENUM_M37(m,d,__VA_ARGS__)) -#define _ENUM_M39(m,d,x,...) m(d,38,x) _ENUM_ID(_ENUM_M38(m,d,__VA_ARGS__)) -#define _ENUM_M40(m,d,x,...) m(d,39,x) _ENUM_ID(_ENUM_M39(m,d,__VA_ARGS__)) -#define _ENUM_M41(m,d,x,...) m(d,40,x) _ENUM_ID(_ENUM_M40(m,d,__VA_ARGS__)) -#define _ENUM_M42(m,d,x,...) m(d,41,x) _ENUM_ID(_ENUM_M41(m,d,__VA_ARGS__)) -#define _ENUM_M43(m,d,x,...) m(d,42,x) _ENUM_ID(_ENUM_M42(m,d,__VA_ARGS__)) -#define _ENUM_M44(m,d,x,...) m(d,43,x) _ENUM_ID(_ENUM_M43(m,d,__VA_ARGS__)) -#define _ENUM_M45(m,d,x,...) m(d,44,x) _ENUM_ID(_ENUM_M44(m,d,__VA_ARGS__)) -#define _ENUM_M46(m,d,x,...) m(d,45,x) _ENUM_ID(_ENUM_M45(m,d,__VA_ARGS__)) -#define _ENUM_M47(m,d,x,...) m(d,46,x) _ENUM_ID(_ENUM_M46(m,d,__VA_ARGS__)) -#define _ENUM_M48(m,d,x,...) m(d,47,x) _ENUM_ID(_ENUM_M47(m,d,__VA_ARGS__)) -#define _ENUM_M49(m,d,x,...) m(d,48,x) _ENUM_ID(_ENUM_M48(m,d,__VA_ARGS__)) -#define _ENUM_M50(m,d,x,...) m(d,49,x) _ENUM_ID(_ENUM_M49(m,d,__VA_ARGS__)) -#define _ENUM_M51(m,d,x,...) m(d,50,x) _ENUM_ID(_ENUM_M50(m,d,__VA_ARGS__)) -#define _ENUM_M52(m,d,x,...) m(d,51,x) _ENUM_ID(_ENUM_M51(m,d,__VA_ARGS__)) -#define _ENUM_M53(m,d,x,...) m(d,52,x) _ENUM_ID(_ENUM_M52(m,d,__VA_ARGS__)) -#define _ENUM_M54(m,d,x,...) m(d,53,x) _ENUM_ID(_ENUM_M53(m,d,__VA_ARGS__)) -#define _ENUM_M55(m,d,x,...) m(d,54,x) _ENUM_ID(_ENUM_M54(m,d,__VA_ARGS__)) -#define _ENUM_M56(m,d,x,...) m(d,55,x) _ENUM_ID(_ENUM_M55(m,d,__VA_ARGS__)) -#define _ENUM_M57(m,d,x,...) m(d,56,x) _ENUM_ID(_ENUM_M56(m,d,__VA_ARGS__)) -#define _ENUM_M58(m,d,x,...) m(d,57,x) _ENUM_ID(_ENUM_M57(m,d,__VA_ARGS__)) -#define _ENUM_M59(m,d,x,...) m(d,58,x) _ENUM_ID(_ENUM_M58(m,d,__VA_ARGS__)) -#define _ENUM_M60(m,d,x,...) m(d,59,x) _ENUM_ID(_ENUM_M59(m,d,__VA_ARGS__)) -#define _ENUM_M61(m,d,x,...) m(d,60,x) _ENUM_ID(_ENUM_M60(m,d,__VA_ARGS__)) -#define _ENUM_M62(m,d,x,...) m(d,61,x) _ENUM_ID(_ENUM_M61(m,d,__VA_ARGS__)) -#define _ENUM_M63(m,d,x,...) m(d,62,x) _ENUM_ID(_ENUM_M62(m,d,__VA_ARGS__)) -#define _ENUM_M64(m,d,x,...) m(d,63,x) _ENUM_ID(_ENUM_M63(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M1(m, d, x) m(d,0,x) +#define BETTER_ENUMS__M2(m,d,x,...) m(d,1,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M1(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M3(m,d,x,...) m(d,2,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M2(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M4(m,d,x,...) m(d,3,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M3(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M5(m,d,x,...) m(d,4,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M4(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M6(m,d,x,...) m(d,5,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M5(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M7(m,d,x,...) m(d,6,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M6(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M8(m,d,x,...) m(d,7,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M7(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M9(m,d,x,...) m(d,8,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M8(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M10(m,d,x,...) m(d,9,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M9(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M11(m,d,x,...) m(d,10,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M10(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M12(m,d,x,...) m(d,11,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M11(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M13(m,d,x,...) m(d,12,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M12(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M14(m,d,x,...) m(d,13,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M13(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M15(m,d,x,...) m(d,14,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M14(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M16(m,d,x,...) m(d,15,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M15(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M17(m,d,x,...) m(d,16,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M16(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M18(m,d,x,...) m(d,17,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M17(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M19(m,d,x,...) m(d,18,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M18(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M20(m,d,x,...) m(d,19,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M19(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M21(m,d,x,...) m(d,20,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M20(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M22(m,d,x,...) m(d,21,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M21(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M23(m,d,x,...) m(d,22,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M22(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M24(m,d,x,...) m(d,23,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M23(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M25(m,d,x,...) m(d,24,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M24(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M26(m,d,x,...) m(d,25,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M25(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M27(m,d,x,...) m(d,26,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M26(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M28(m,d,x,...) m(d,27,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M27(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M29(m,d,x,...) m(d,28,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M28(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M30(m,d,x,...) m(d,29,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M29(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M31(m,d,x,...) m(d,30,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M30(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M32(m,d,x,...) m(d,31,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M31(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M33(m,d,x,...) m(d,32,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M32(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M34(m,d,x,...) m(d,33,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M33(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M35(m,d,x,...) m(d,34,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M34(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M36(m,d,x,...) m(d,35,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M35(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M37(m,d,x,...) m(d,36,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M36(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M38(m,d,x,...) m(d,37,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M37(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M39(m,d,x,...) m(d,38,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M38(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M40(m,d,x,...) m(d,39,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M39(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M41(m,d,x,...) m(d,40,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M40(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M42(m,d,x,...) m(d,41,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M41(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M43(m,d,x,...) m(d,42,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M42(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M44(m,d,x,...) m(d,43,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M43(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M45(m,d,x,...) m(d,44,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M44(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M46(m,d,x,...) m(d,45,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M45(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M47(m,d,x,...) m(d,46,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M46(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M48(m,d,x,...) m(d,47,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M47(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M49(m,d,x,...) m(d,48,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M48(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M50(m,d,x,...) m(d,49,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M49(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M51(m,d,x,...) m(d,50,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M50(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M52(m,d,x,...) m(d,51,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M51(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M53(m,d,x,...) m(d,52,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M52(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M54(m,d,x,...) m(d,53,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M53(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M55(m,d,x,...) m(d,54,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M54(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M56(m,d,x,...) m(d,55,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M55(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M57(m,d,x,...) m(d,56,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M56(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M58(m,d,x,...) m(d,57,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M57(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M59(m,d,x,...) m(d,58,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M58(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M60(m,d,x,...) m(d,59,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M59(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M61(m,d,x,...) m(d,60,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M60(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M62(m,d,x,...) m(d,61,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M61(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M63(m,d,x,...) m(d,62,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M62(m,d,__VA_ARGS__)) +#define BETTER_ENUMS__M64(m,d,x,...) m(d,63,x) \ + BETTER_ENUMS__ID(BETTER_ENUMS__M63(m,d,__VA_ARGS__)) -#define _ENUM_PP_COUNT_IMPL(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, \ - _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, \ - _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, \ - _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, \ - _58, _59, _60, _61, _62, _63, _64, count, ...) count +#define BETTER_ENUMS__PP_COUNT_IMPL(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \ + _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, \ + _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, \ + _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, \ + _56, _57, _58, _59, _60, _61, _62, _63, _64, count, ...) count -#define _ENUM_PP_COUNT(...) _ENUM_ID(_ENUM_PP_COUNT_IMPL(__VA_ARGS__, 64, 63, \ - 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44,\ - 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25,\ - 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, \ - 4, 3, 2, 1)) +#define BETTER_ENUMS__PP_COUNT(...) \ + BETTER_ENUMS__ID(BETTER_ENUMS__PP_COUNT_IMPL(__VA_ARGS__, 64, 63, 62, 61, \ + 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43,\ + 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25,\ + 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,\ + 5, 4, 3, 2, 1)) -#define _ENUM_ITERATE(X, f, l) X(f, l, 0) X(f, l, 1) X(f, l, 2) X(f, l, 3) \ - X(f, l, 4) X(f, l, 5) X(f, l, 6) X(f, l, 7) X(f, l, 8) X(f, l, 9) \ - X(f, l, 10) X(f, l, 11) X(f, l, 12) X(f, l, 13) X(f, l, 14) X(f, l, 15) \ - X(f, l, 16) X(f, l, 17) X(f, l, 18) X(f, l, 19) X(f, l, 20) X(f, l, 21) \ - X(f, l, 22) X(f, l, 23) +#define BETTER_ENUMS__ITERATE(X, f, l) X(f, l, 0) X(f, l, 1) X(f, l, 2) \ + X(f, l, 3) X(f, l, 4) X(f, l, 5) X(f, l, 6) X(f, l, 7) X(f, l, 8) \ + X(f, l, 9) X(f, l, 10) X(f, l, 11) X(f, l, 12) X(f, l, 13) X(f, l, 14) \ + X(f, l, 15) X(f, l, 16) X(f, l, 17) X(f, l, 18) X(f, l, 19) X(f, l, 20) \ + X(f, l, 21) X(f, l, 22) X(f, l, 23) -#endif // #ifdef BETTER_ENUMS_MACRO_FILE +#endif // #ifdef BETTER_ENUMS_MACRO_FILE else case -#define _ENUM_EAT_ASSIGN_SINGLE(EnumType, index, expression) \ +#define BETTER_ENUMS__EAT_ASSIGN_SINGLE(EnumType, index, expression) \ ((better_enums::_eat_assign)EnumType::expression), -#define _ENUM_EAT_ASSIGN(EnumType, ...) \ - _ENUM_ID(_ENUM_PP_MAP(_ENUM_EAT_ASSIGN_SINGLE, EnumType, __VA_ARGS__)) +#define BETTER_ENUMS__EAT_ASSIGN(EnumType, ...) \ + BETTER_ENUMS__ID( \ + BETTER_ENUMS__PP_MAP( \ + BETTER_ENUMS__EAT_ASSIGN_SINGLE, EnumType, __VA_ARGS__)) -#define _ENUM_NS(EnumType) better_enums::_data_ ## EnumType -#define _ENUM_NAME_ENDERS "= \t\n" +#define BETTER_ENUMS__NS(EnumType) better_enums::_data_ ## EnumType +#define BETTER_ENUMS__NAME_ENDERS "= \t\n" namespace better_enums { template -_ENUM_CONSTEXPR inline T _default() +BETTER_ENUMS__CONSTEXPR inline T _default() { return (typename T::_enumerated)0; } template <> -_ENUM_CONSTEXPR inline const char* _default() +BETTER_ENUMS__CONSTEXPR inline const char* _default() { - return _ENUM_NULLPTR; + return BETTER_ENUMS__NULLPTR; } template <> -_ENUM_CONSTEXPR inline std::size_t _default() +BETTER_ENUMS__CONSTEXPR inline std::size_t _default() { return 0; } template struct optional { - _ENUM_CONSTEXPR optional() : _valid(false), _value(_default()) { } - _ENUM_CONSTEXPR optional(T v) : _valid(true), _value(v) { } + BETTER_ENUMS__CONSTEXPR optional() : + _valid(false), _value(_default()) { } - _ENUM_CONSTEXPR const T& operator *() const { return _value; } - _ENUM_CONSTEXPR const T* operator ->() const { return &_value; } + BETTER_ENUMS__CONSTEXPR optional(T v) : _valid(true), _value(v) { } - _ENUM_CONSTEXPR operator bool() const { return _valid; } + BETTER_ENUMS__CONSTEXPR const T& operator *() const { return _value; } + BETTER_ENUMS__CONSTEXPR const T* operator ->() const { return &_value; } - _ENUM_CONSTEXPR const T& value() const { return _value; } + BETTER_ENUMS__CONSTEXPR operator bool() const { return _valid; } + + BETTER_ENUMS__CONSTEXPR const T& value() const { return _value; } private: bool _valid; @@ -204,14 +283,15 @@ struct optional { }; template -_ENUM_CONSTEXPR static optional +BETTER_ENUMS__CONSTEXPR static optional _map_index(const Element *array, optional index) { return index ? (CastTo)array[*index] : optional(); } template -_ENUM_CONSTEXPR static T _or_throw(optional maybe, const char *message) +BETTER_ENUMS__CONSTEXPR static T _or_throw(optional maybe, + const char *message) { return maybe ? *maybe : throw std::runtime_error(message); } @@ -219,17 +299,20 @@ _ENUM_CONSTEXPR static T _or_throw(optional maybe, const char *message) template -_ENUM_CONSTEXPR U continue_with(T ignored, U value) { return value; } +BETTER_ENUMS__CONSTEXPR U continue_with(T ignored, U value) { return value; } template struct _eat_assign { - explicit _ENUM_CONSTEXPR _eat_assign(EnumType value) : _value(value) { } + explicit BETTER_ENUMS__CONSTEXPR _eat_assign(EnumType value) : _value(value) + { } + template - _ENUM_CONSTEXPR const _eat_assign& operator =(Any dummy) const + BETTER_ENUMS__CONSTEXPR const _eat_assign& operator =(Any dummy) const { return *this; } - _ENUM_CONSTEXPR operator EnumType () const { return _value; } + + BETTER_ENUMS__CONSTEXPR operator EnumType () const { return _value; } private: EnumType _value; @@ -241,13 +324,14 @@ template struct _Iterable { typedef const Element* iterator; - _ENUM_CONSTEXPR iterator begin() const { return iterator(_array); } - _ENUM_CONSTEXPR iterator end() const { return iterator(_array + _size); } - _ENUM_CONSTEXPR std::size_t size() const { return _size; } - _ENUM_CONSTEXPR const Element& operator [](std::size_t index) const + BETTER_ENUMS__CONSTEXPR iterator begin() const { return iterator(_array); } + BETTER_ENUMS__CONSTEXPR iterator end() const + { return iterator(_array + _size); } + BETTER_ENUMS__CONSTEXPR std::size_t size() const { return _size; } + BETTER_ENUMS__CONSTEXPR const Element& operator [](std::size_t index) const { return _array[index]; } - _ENUM_CONSTEXPR _Iterable(const Element *array, std::size_t s) : + BETTER_ENUMS__CONSTEXPR _Iterable(const Element *array, std::size_t s) : _array(array), _size(s) { } private: @@ -257,16 +341,16 @@ struct _Iterable { -_ENUM_CONSTEXPR inline bool _endsName(char c, std::size_t index = 0) +BETTER_ENUMS__CONSTEXPR inline bool _endsName(char c, std::size_t index = 0) { return - c == _ENUM_NAME_ENDERS[index] ? true : - _ENUM_NAME_ENDERS[index] == '\0' ? false : + c == BETTER_ENUMS__NAME_ENDERS[index] ? true : + BETTER_ENUMS__NAME_ENDERS[index] == '\0' ? false : _endsName(c, index + 1); } -_ENUM_CONSTEXPR inline bool _hasExplicitValue(const char *s, - std::size_t index = 0) +BETTER_ENUMS__CONSTEXPR inline bool _hasExplicitValue(const char *s, + std::size_t index = 0) { return s[index] == '\0' ? false : @@ -274,26 +358,26 @@ _ENUM_CONSTEXPR inline bool _hasExplicitValue(const char *s, _hasExplicitValue(s, index + 1); } -_ENUM_CONSTEXPR inline std::size_t _constantLength(const char *s, - std::size_t index = 0) +BETTER_ENUMS__CONSTEXPR inline std::size_t +_constantLength(const char *s, std::size_t index = 0) { return _endsName(s[index]) ? index : _constantLength(s, index + 1); } -_ENUM_CONSTEXPR inline char _select(const char *from, std::size_t from_length, - std::size_t index) +BETTER_ENUMS__CONSTEXPR inline char +_select(const char *from, std::size_t from_length, std::size_t index) { return index >= from_length ? '\0' : from[index]; } -_ENUM_CONSTEXPR inline char _toLowercaseAscii(char c) +BETTER_ENUMS__CONSTEXPR inline char _toLowercaseAscii(char c) { return c >= 0x41 && c <= 0x5A ? (char)(c + 0x20) : c; } -_ENUM_CONSTEXPR inline bool _namesMatch(const char *stringizedName, - const char *referenceName, - std::size_t index = 0) +BETTER_ENUMS__CONSTEXPR inline bool _namesMatch(const char *stringizedName, + const char *referenceName, + std::size_t index = 0) { return _endsName(stringizedName[index]) ? referenceName[index] == '\0' : @@ -302,9 +386,9 @@ _ENUM_CONSTEXPR inline bool _namesMatch(const char *stringizedName, _namesMatch(stringizedName, referenceName, index + 1); } -_ENUM_CONSTEXPR inline bool _namesMatchNocase(const char *stringizedName, - const char *referenceName, - std::size_t index = 0) +BETTER_ENUMS__CONSTEXPR inline bool +_namesMatchNocase(const char *stringizedName, const char *referenceName, + std::size_t index = 0) { return _endsName(stringizedName[index]) ? referenceName[index] == '\0' : @@ -318,7 +402,8 @@ inline void _trim_names(const char * const *raw_names, const char **trimmed_names, std::size_t count) { for (std::size_t index = 0; index < count; ++index) { - std::size_t length = std::strcspn(raw_names[index], _ENUM_NAME_ENDERS); + std::size_t length = + std::strcspn(raw_names[index], BETTER_ENUMS__NAME_ENDERS); char *trimmed = new char[length + 1]; std::strncpy(trimmed, raw_names[index], length); @@ -332,58 +417,65 @@ inline void _trim_names(const char * const *raw_names, -#ifdef _ENUM_HAVE_CONSTEXPR +#ifdef BETTER_ENUMS__HAVE_CONSTEXPR -#define _ENUM_SELECT_SINGLE_CHARACTER(from, from_length, index) \ +#define BETTER_ENUMS__SELECT_SINGLE_CHARACTER(from, from_length, index) \ _select(from, from_length, index), -#define _ENUM_SELECT_CHARACTERS(from, from_length) \ - _ENUM_ITERATE(_ENUM_SELECT_SINGLE_CHARACTER, from, from_length) +#define BETTER_ENUMS__SELECT_CHARACTERS(from, from_length) \ + BETTER_ENUMS__ITERATE( \ + BETTER_ENUMS__SELECT_SINGLE_CHARACTER, from, from_length) -#define _ENUM_TRIM_SINGLE_STRING(ignored, index, expression) \ +#define BETTER_ENUMS__TRIM_SINGLE_STRING(ignored, index, expression) \ constexpr std::size_t _length_ ## index = _constantLength(#expression); \ constexpr const char _trimmed_ ## index [] = \ - { _ENUM_SELECT_CHARACTERS(#expression, _length_ ## index) }; \ + { BETTER_ENUMS__SELECT_CHARACTERS(#expression, _length_ ## index) }; \ constexpr const char *_final_ ## index = \ _hasExplicitValue(#expression) ? _trimmed_ ## index : #expression; -#define _ENUM_TRIM_STRINGS(...) \ - _ENUM_ID(_ENUM_PP_MAP(_ENUM_TRIM_SINGLE_STRING, ignored, __VA_ARGS__)) +#define BETTER_ENUMS__TRIM_STRINGS(...) \ + BETTER_ENUMS__ID( \ + BETTER_ENUMS__PP_MAP( \ + BETTER_ENUMS__TRIM_SINGLE_STRING, ignored, __VA_ARGS__)) -#define _ENUM_REFER_TO_SINGLE_STRING(ignored, index, expression) \ +#define BETTER_ENUMS__REFER_TO_SINGLE_STRING(ignored, index, expression) \ _final_ ## index, -#define _ENUM_REFER_TO_STRINGS(...) \ - _ENUM_ID(_ENUM_PP_MAP(_ENUM_REFER_TO_SINGLE_STRING, ignored, __VA_ARGS__)) +#define BETTER_ENUMS__REFER_TO_STRINGS(...) \ + BETTER_ENUMS__ID( \ + BETTER_ENUMS__PP_MAP( \ + BETTER_ENUMS__REFER_TO_SINGLE_STRING, ignored, __VA_ARGS__)) -#endif // #ifdef _ENUM_HAVE_CONSTEXPR +#endif // #ifdef BETTER_ENUMS__HAVE_CONSTEXPR -#define _ENUM_STRINGIZE_SINGLE(ignored, index, expression) #expression, +#define BETTER_ENUMS__STRINGIZE_SINGLE(ignored, index, expression) #expression, -#define _ENUM_STRINGIZE(...) \ - _ENUM_ID(_ENUM_PP_MAP(_ENUM_STRINGIZE_SINGLE, ignored, __VA_ARGS__)) +#define BETTER_ENUMS__STRINGIZE(...) \ + BETTER_ENUMS__ID( \ + BETTER_ENUMS__PP_MAP( \ + BETTER_ENUMS__STRINGIZE_SINGLE, ignored, __VA_ARGS__)) -#define _ENUM_TYPE(SetUnderlyingType, SwitchType, GenerateSwitchType, \ - GenerateStrings, ToStringConstexpr, \ - DeclareInitialize, DefineInitialize, CallInitialize, \ - Enum, Integral, ...) \ +#define BETTER_ENUMS__TYPE(SetUnderlyingType, SwitchType, GenerateSwitchType, \ + GenerateStrings, ToStringConstexpr, \ + DeclareInitialize, DefineInitialize, CallInitialize,\ + Enum, Integral, ...) \ \ namespace better_enums { \ namespace _data_ ## Enum { \ \ -_ENUM_ID(GenerateSwitchType(Integral, __VA_ARGS__)) \ +BETTER_ENUMS__ID(GenerateSwitchType(Integral, __VA_ARGS__)) \ \ } \ } \ @@ -397,29 +489,32 @@ class Enum { \ enum _enumerated SetUnderlyingType(Integral) { __VA_ARGS__ }; \ typedef Integral _integral; \ \ - _ENUM_CONSTEXPR Enum(_enumerated value) : _value(value) { } \ + BETTER_ENUMS__CONSTEXPR Enum(_enumerated value) : _value(value) { } \ \ - _ENUM_CONSTEXPR operator SwitchType(Enum)() const \ + BETTER_ENUMS__CONSTEXPR operator SwitchType(Enum)() const \ { \ return (SwitchType(Enum))_value; \ } \ \ - _ENUM_CONSTEXPR _integral _to_integral() const; \ - _ENUM_CONSTEXPR static Enum _from_integral(_integral value); \ - _ENUM_CONSTEXPR static Enum _from_integral_unchecked(_integral value); \ - _ENUM_CONSTEXPR static _optional _from_integral_nothrow(_integral value); \ + BETTER_ENUMS__CONSTEXPR _integral _to_integral() const; \ + BETTER_ENUMS__CONSTEXPR static Enum _from_integral(_integral value); \ + BETTER_ENUMS__CONSTEXPR static Enum \ + _from_integral_unchecked(_integral value); \ + BETTER_ENUMS__CONSTEXPR static _optional \ + _from_integral_nothrow(_integral value); \ \ ToStringConstexpr const char* _to_string() const; \ - _ENUM_CONSTEXPR static Enum _from_string(const char *name); \ - _ENUM_CONSTEXPR static _optional _from_string_nothrow(const char *name); \ + BETTER_ENUMS__CONSTEXPR static Enum _from_string(const char *name); \ + BETTER_ENUMS__CONSTEXPR static _optional \ + _from_string_nothrow(const char *name); \ \ - _ENUM_CONSTEXPR static Enum _from_string_nocase(const char *name); \ - _ENUM_CONSTEXPR static _optional \ + BETTER_ENUMS__CONSTEXPR static Enum _from_string_nocase(const char *name); \ + BETTER_ENUMS__CONSTEXPR static _optional \ _from_string_nocase_nothrow(const char *name); \ \ - _ENUM_CONSTEXPR static bool _is_valid(_integral value); \ - _ENUM_CONSTEXPR static bool _is_valid(const char *name); \ - _ENUM_CONSTEXPR static bool _is_valid_nocase(const char *name); \ + BETTER_ENUMS__CONSTEXPR static bool _is_valid(_integral value); \ + BETTER_ENUMS__CONSTEXPR static bool _is_valid(const char *name); \ + BETTER_ENUMS__CONSTEXPR static bool _is_valid_nocase(const char *name); \ \ typedef better_enums::_Iterable _value_iterable; \ typedef better_enums::_Iterable _name_iterable; \ @@ -427,11 +522,11 @@ class Enum { \ typedef _value_iterable::iterator _value_iterator; \ typedef _name_iterable::iterator _name_iterator; \ \ - _ENUM_CONSTEXPR static const std::size_t _size = \ - _ENUM_ID(_ENUM_PP_COUNT(__VA_ARGS__)); \ + BETTER_ENUMS__CONSTEXPR static const std::size_t _size = \ + BETTER_ENUMS__ID(BETTER_ENUMS__PP_COUNT(__VA_ARGS__)); \ \ - _ENUM_CONSTEXPR static const char* _name(); \ - _ENUM_CONSTEXPR static _value_iterable _values(); \ + BETTER_ENUMS__CONSTEXPR static const char* _name(); \ + BETTER_ENUMS__CONSTEXPR static _value_iterable _values(); \ ToStringConstexpr static _name_iterable _names(); \ \ _integral _value; \ @@ -441,11 +536,11 @@ class Enum { \ \ DeclareInitialize \ \ - _ENUM_CONSTEXPR static _optional_index \ + BETTER_ENUMS__CONSTEXPR static _optional_index \ _from_int_loop(_integral value, std::size_t index = 0); \ - _ENUM_CONSTEXPR static _optional_index \ + BETTER_ENUMS__CONSTEXPR static _optional_index \ _from_string_loop(const char *name, std::size_t index = 0); \ - _ENUM_CONSTEXPR static _optional_index \ + BETTER_ENUMS__CONSTEXPR static _optional_index \ _from_string_nocase_loop(const char *name, std::size_t index = 0); \ }; \ \ @@ -454,40 +549,43 @@ namespace _data_ ## Enum { \ \ enum PutNamesInThisScopeAlso { __VA_ARGS__ }; \ \ -_ENUM_CONSTEXPR const Enum value_array[] = \ - { _ENUM_ID(_ENUM_EAT_ASSIGN(Enum, __VA_ARGS__)) }; \ +BETTER_ENUMS__CONSTEXPR const Enum value_array[] = \ + { BETTER_ENUMS__ID(BETTER_ENUMS__EAT_ASSIGN(Enum, __VA_ARGS__)) }; \ \ -_ENUM_ID(GenerateStrings(Enum, __VA_ARGS__)) \ +BETTER_ENUMS__ID(GenerateStrings(Enum, __VA_ARGS__)) \ \ } \ } \ \ -_ENUM_CONSTEXPR inline const Enum operator +(Enum::_enumerated enumerated) \ - { return (Enum)enumerated; } \ +BETTER_ENUMS__CONSTEXPR inline const Enum \ +operator +(Enum::_enumerated enumerated) \ +{ \ + return (Enum)enumerated; \ +} \ \ -_ENUM_CONSTEXPR inline Enum::_integral Enum::_to_integral() const \ +BETTER_ENUMS__CONSTEXPR inline Enum::_integral Enum::_to_integral() const \ { \ return _value; \ } \ \ -_ENUM_CONSTEXPR inline Enum \ +BETTER_ENUMS__CONSTEXPR inline Enum \ Enum::_from_integral_unchecked(Enum::_integral value) \ { \ return (_enumerated)value; \ } \ \ -_ENUM_CONSTEXPR inline Enum Enum::_from_integral(Enum::_integral value) \ +BETTER_ENUMS__CONSTEXPR inline Enum Enum::_from_integral(Enum::_integral value)\ { \ return \ better_enums::_or_throw(_from_integral_nothrow(value), \ "Enum::_from_integral: invalid argument"); \ } \ \ -_ENUM_CONSTEXPR inline Enum::_optional \ +BETTER_ENUMS__CONSTEXPR inline Enum::_optional \ Enum::_from_integral_nothrow(Enum::_integral value) \ { \ return \ - better_enums::_map_index(_ENUM_NS(Enum)::value_array, \ + better_enums::_map_index(BETTER_ENUMS__NS(Enum)::value_array, \ _from_int_loop(value)); \ } \ \ @@ -496,147 +594,150 @@ ToStringConstexpr inline const char* Enum::_to_string() const \ return \ better_enums::_or_throw( \ better_enums::_map_index( \ - _ENUM_NS(Enum)::name_array(), \ + BETTER_ENUMS__NS(Enum)::name_array(), \ _from_int_loop(CallInitialize(_value))), \ "Enum::to_string: invalid enum value"); \ } \ \ -_ENUM_CONSTEXPR inline Enum Enum::_from_string(const char *name) \ +BETTER_ENUMS__CONSTEXPR inline Enum Enum::_from_string(const char *name) \ { \ return \ better_enums::_or_throw(_from_string_nothrow(name), \ "Enum::_from_string: invalid argument"); \ } \ \ -_ENUM_CONSTEXPR inline Enum::_optional \ +BETTER_ENUMS__CONSTEXPR inline Enum::_optional \ Enum::_from_string_nothrow(const char *name) \ { \ return \ better_enums::_map_index( \ - _ENUM_NS(Enum)::value_array, _from_string_loop(name)); \ + BETTER_ENUMS__NS(Enum)::value_array, _from_string_loop(name)); \ } \ \ -_ENUM_CONSTEXPR inline Enum Enum::_from_string_nocase(const char *name) \ +BETTER_ENUMS__CONSTEXPR inline Enum Enum::_from_string_nocase(const char *name)\ { \ return \ better_enums::_or_throw(_from_string_nocase_nothrow(name), \ "Enum::_from_string_nocase: invalid argument");\ } \ \ -_ENUM_CONSTEXPR inline Enum::_optional \ +BETTER_ENUMS__CONSTEXPR inline Enum::_optional \ Enum::_from_string_nocase_nothrow(const char *name) \ { \ return \ - better_enums::_map_index(_ENUM_NS(Enum)::value_array, \ + better_enums::_map_index(BETTER_ENUMS__NS(Enum)::value_array, \ _from_string_nocase_loop(name)); \ } \ \ -_ENUM_CONSTEXPR inline bool Enum::_is_valid(Enum::_integral value) \ +BETTER_ENUMS__CONSTEXPR inline bool Enum::_is_valid(Enum::_integral value) \ { \ return _from_int_loop(value); \ } \ \ -_ENUM_CONSTEXPR inline bool Enum::_is_valid(const char *name) \ +BETTER_ENUMS__CONSTEXPR inline bool Enum::_is_valid(const char *name) \ { \ return _from_string_loop(name); \ } \ \ -_ENUM_CONSTEXPR inline bool Enum::_is_valid_nocase(const char *name) \ +BETTER_ENUMS__CONSTEXPR inline bool Enum::_is_valid_nocase(const char *name) \ { \ return _from_string_nocase_loop(name); \ } \ \ -_ENUM_CONSTEXPR inline const char* Enum::_name() \ +BETTER_ENUMS__CONSTEXPR inline const char* Enum::_name() \ { \ return #Enum; \ } \ \ -_ENUM_CONSTEXPR inline Enum::_value_iterable Enum::_values() \ +BETTER_ENUMS__CONSTEXPR inline Enum::_value_iterable Enum::_values() \ { \ - return _value_iterable(_ENUM_NS(Enum)::value_array, _size); \ + return _value_iterable(BETTER_ENUMS__NS(Enum)::value_array, _size); \ } \ \ ToStringConstexpr inline Enum::_name_iterable Enum::_names() \ { \ - return _name_iterable(_ENUM_NS(Enum)::name_array(), CallInitialize(_size));\ + return \ + _name_iterable(BETTER_ENUMS__NS(Enum)::name_array(), \ + CallInitialize(_size)); \ } \ \ DefineInitialize(Enum) \ \ -_ENUM_CONSTEXPR inline Enum::_optional_index \ +BETTER_ENUMS__CONSTEXPR inline Enum::_optional_index \ Enum::_from_int_loop(Enum::_integral value, std::size_t index) \ { \ return \ index == _size ? _optional_index() : \ - _ENUM_NS(Enum)::value_array[index]._value == value ? \ + BETTER_ENUMS__NS(Enum)::value_array[index]._value == value ? \ _optional_index(index) : \ _from_int_loop(value, index + 1); \ } \ \ -_ENUM_CONSTEXPR inline Enum::_optional_index \ +BETTER_ENUMS__CONSTEXPR inline Enum::_optional_index \ Enum::_from_string_loop(const char *name, std::size_t index) \ { \ return \ index == _size ? _optional_index() : \ - better_enums::_namesMatch(_ENUM_NS(Enum)::raw_names()[index], name) ? \ + better_enums::_namesMatch(BETTER_ENUMS__NS(Enum)::raw_names()[index], \ + name) ? \ _optional_index(index) : \ - _from_string_loop(name, index + 1); \ + _from_string_loop(name, index + 1); \ } \ \ -_ENUM_CONSTEXPR inline Enum::_optional_index \ +BETTER_ENUMS__CONSTEXPR inline Enum::_optional_index \ Enum::_from_string_nocase_loop(const char *name, std::size_t index) \ { \ return \ index == _size ? _optional_index() : \ better_enums::_namesMatchNocase( \ - _ENUM_NS(Enum)::raw_names()[index], name) ? \ + BETTER_ENUMS__NS(Enum)::raw_names()[index], name) ? \ _optional_index(index) : \ _from_string_nocase_loop(name, index + 1); \ } \ \ -_ENUM_CONSTEXPR inline bool operator ==(const Enum &a, const Enum &b) \ +BETTER_ENUMS__CONSTEXPR inline bool operator ==(const Enum &a, const Enum &b) \ { return a._value == b._value; } \ -_ENUM_CONSTEXPR inline bool operator !=(const Enum &a, const Enum &b) \ +BETTER_ENUMS__CONSTEXPR inline bool operator !=(const Enum &a, const Enum &b) \ { return a._value != b._value; } \ -_ENUM_CONSTEXPR inline bool operator <(const Enum &a, const Enum &b) \ +BETTER_ENUMS__CONSTEXPR inline bool operator <(const Enum &a, const Enum &b) \ { return a._value < b._value; } \ -_ENUM_CONSTEXPR inline bool operator <=(const Enum &a, const Enum &b) \ +BETTER_ENUMS__CONSTEXPR inline bool operator <=(const Enum &a, const Enum &b) \ { return a._value <= b._value; } \ -_ENUM_CONSTEXPR inline bool operator >(const Enum &a, const Enum &b) \ +BETTER_ENUMS__CONSTEXPR inline bool operator >(const Enum &a, const Enum &b) \ { return a._value > b._value; } \ -_ENUM_CONSTEXPR inline bool operator >=(const Enum &a, const Enum &b) \ +BETTER_ENUMS__CONSTEXPR inline bool operator >=(const Enum &a, const Enum &b) \ { return a._value >= b._value; } // C++98, C++11 -#define _ENUM_CXX98_UNDERLYING_TYPE(Integral) +#define BETTER_ENUMS__CXX98_UNDERLYING_TYPE(Integral) // C++11 -#define _ENUM_CXX11_UNDERLYING_TYPE(Integral) \ +#define BETTER_ENUMS__CXX11_UNDERLYING_TYPE(Integral) \ : Integral // C++98, C++11 -#define _ENUM_REGULAR_ENUM_SWITCH_TYPE(Type) \ +#define BETTER_ENUMS__REGULAR_ENUM_SWITCH_TYPE(Type) \ _enumerated // C++11 -#define _ENUM_ENUM_CLASS_SWITCH_TYPE(Type) \ - _ENUM_NS(Type)::EnumClassForSwitchStatements +#define BETTER_ENUMS__ENUM_CLASS_SWITCH_TYPE(Type) \ + BETTER_ENUMS__NS(Type)::EnumClassForSwitchStatements // C++98, C++11 -#define _ENUM_REGULAR_ENUM_SWITCH_TYPE_GENERATE(Integral, ...) +#define BETTER_ENUMS__REGULAR_ENUM_SWITCH_TYPE_GENERATE(Integral, ...) // C++11 -#define _ENUM_ENUM_CLASS_SWITCH_TYPE_GENERATE(Integral, ...) \ +#define BETTER_ENUMS__ENUM_CLASS_SWITCH_TYPE_GENERATE(Integral, ...) \ enum class EnumClassForSwitchStatements : Integral { __VA_ARGS__ }; // C++98 -#define _ENUM_CXX98_TRIM_STRINGS_ARRAYS(Enum, ...) \ +#define BETTER_ENUMS__CXX98_TRIM_STRINGS_ARRAYS(Enum, ...) \ inline const char** raw_names() \ { \ static const char *value[] = \ - { _ENUM_ID(_ENUM_STRINGIZE(__VA_ARGS__)) }; \ + { BETTER_ENUMS__ID(BETTER_ENUMS__STRINGIZE(__VA_ARGS__)) }; \ return value; \ } \ \ @@ -653,9 +754,9 @@ _ENUM_CONSTEXPR inline bool operator >=(const Enum &a, const Enum &b) \ } // C++11 fast version -#define _ENUM_CXX11_PARTIAL_CONSTEXPR_TRIM_STRINGS_ARRAYS(Enum, ...) \ +#define BETTER_ENUMS__CXX11_PARTIAL_CONSTEXPR_TRIM_STRINGS_ARRAYS(Enum, ...) \ constexpr const char *the_raw_names[] = \ - { _ENUM_ID(_ENUM_STRINGIZE(__VA_ARGS__)) }; \ + { BETTER_ENUMS__ID(BETTER_ENUMS__STRINGIZE(__VA_ARGS__)) }; \ \ constexpr const char * const * raw_names() \ { \ @@ -675,11 +776,11 @@ _ENUM_CONSTEXPR inline bool operator >=(const Enum &a, const Enum &b) \ } // C++11 slow all-constexpr version -#define _ENUM_CXX11_FULL_CONSTEXPR_TRIM_STRINGS_ARRAYS(Enum, ...) \ - _ENUM_ID(_ENUM_TRIM_STRINGS(__VA_ARGS__)) \ +#define BETTER_ENUMS__CXX11_FULL_CONSTEXPR_TRIM_STRINGS_ARRAYS(Enum, ...) \ + BETTER_ENUMS__ID(BETTER_ENUMS__TRIM_STRINGS(__VA_ARGS__)) \ \ constexpr const char * const the_name_array[] = \ - { _ENUM_ID(_ENUM_REFER_TO_STRINGS(__VA_ARGS__)) }; \ + { BETTER_ENUMS__ID(BETTER_ENUMS__REFER_TO_STRINGS(__VA_ARGS__)) }; \ \ constexpr const char * const * name_array() \ { \ @@ -692,127 +793,127 @@ _ENUM_CONSTEXPR inline bool operator >=(const Enum &a, const Enum &b) \ } // C++98, C++11 fast version -#define _ENUM_NO_CONSTEXPR_TO_STRING_KEYWORD +#define BETTER_ENUMS__NO_CONSTEXPR_TO_STRING_KEYWORD // C++11 slow all-constexpr version -#define _ENUM_CONSTEXPR_TO_STRING_KEYWORD \ +#define BETTER_ENUMS__CONSTEXPR_TO_STRING_KEYWORD \ constexpr // C++98, C++11 fast version -#define _ENUM_DO_DECLARE_INITIALIZE \ +#define BETTER_ENUMS__DO_DECLARE_INITIALIZE \ static int initialize(); // C++11 slow all-constexpr version -#define _ENUM_DO_NOT_DECLARE_INITIALIZE +#define BETTER_ENUMS__DO_NOT_DECLARE_INITIALIZE // C++98, C++11 fast version -#define _ENUM_DO_DEFINE_INITIALIZE(Enum) \ +#define BETTER_ENUMS__DO_DEFINE_INITIALIZE(Enum) \ inline int Enum::initialize() \ { \ - if (_ENUM_NS(Enum)::initialized()) \ + if (BETTER_ENUMS__NS(Enum)::initialized()) \ return 0; \ \ - better_enums::_trim_names(_ENUM_NS(Enum)::raw_names(), \ - _ENUM_NS(Enum)::name_array(), _size); \ + better_enums::_trim_names(BETTER_ENUMS__NS(Enum)::raw_names(), \ + BETTER_ENUMS__NS(Enum)::name_array(), _size);\ \ - _ENUM_NS(Enum)::initialized() = true; \ + BETTER_ENUMS__NS(Enum)::initialized() = true; \ \ return 0; \ } // C++11 slow all-constexpr version -#define _ENUM_DO_NOT_DEFINE_INITIALIZE(Enum) +#define BETTER_ENUMS__DO_NOT_DEFINE_INITIALIZE(Enum) // C++98, C++11 fast version -#define _ENUM_DO_CALL_INITIALIZE(value) \ +#define BETTER_ENUMS__DO_CALL_INITIALIZE(value) \ better_enums::continue_with(initialize(), value) // C++11 slow all-constexpr version -#define _ENUM_DO_NOT_CALL_INITIALIZE(value) \ +#define BETTER_ENUMS__DO_NOT_CALL_INITIALIZE(value) \ value #ifdef BETTER_ENUMS_STRICT_CONVERSION -# define _ENUM_DEFAULT_SWITCH_TYPE \ - _ENUM_ENUM_CLASS_SWITCH_TYPE -# define _ENUM_DEFAULT_SWITCH_TYPE_GENERATE \ - _ENUM_ENUM_CLASS_SWITCH_TYPE_GENERATE +# define BETTER_ENUMS__DEFAULT_SWITCH_TYPE \ + BETTER_ENUMS__ENUM_CLASS_SWITCH_TYPE +# define BETTER_ENUMS__DEFAULT_SWITCH_TYPE_GENERATE \ + BETTER_ENUMS__ENUM_CLASS_SWITCH_TYPE_GENERATE #else -# define _ENUM_DEFAULT_SWITCH_TYPE \ - _ENUM_REGULAR_ENUM_SWITCH_TYPE -# define _ENUM_DEFAULT_SWITCH_TYPE_GENERATE \ - _ENUM_REGULAR_ENUM_SWITCH_TYPE_GENERATE +# define BETTER_ENUMS__DEFAULT_SWITCH_TYPE \ + BETTER_ENUMS__REGULAR_ENUM_SWITCH_TYPE +# define BETTER_ENUMS__DEFAULT_SWITCH_TYPE_GENERATE \ + BETTER_ENUMS__REGULAR_ENUM_SWITCH_TYPE_GENERATE #endif -#ifdef _ENUM_HAVE_CONSTEXPR +#ifdef BETTER_ENUMS__HAVE_CONSTEXPR #ifdef BETTER_ENUMS_CONSTEXPR_TO_STRING -# define _ENUM_DEFAULT_TRIM_STRINGS_ARRAYS \ - _ENUM_CXX11_FULL_CONSTEXPR_TRIM_STRINGS_ARRAYS -# define _ENUM_DEFAULT_TO_STRING_KEYWORD \ - _ENUM_CONSTEXPR_TO_STRING_KEYWORD -# define _ENUM_DEFAULT_DECLARE_INITIALIZE \ - _ENUM_DO_NOT_DECLARE_INITIALIZE -# define _ENUM_DEFAULT_DEFINE_INITIALIZE \ - _ENUM_DO_NOT_DEFINE_INITIALIZE -# define _ENUM_DEFAULT_CALL_INITIALIZE \ - _ENUM_DO_NOT_CALL_INITIALIZE +# define BETTER_ENUMS__DEFAULT_TRIM_STRINGS_ARRAYS \ + BETTER_ENUMS__CXX11_FULL_CONSTEXPR_TRIM_STRINGS_ARRAYS +# define BETTER_ENUMS__DEFAULT_TO_STRING_KEYWORD \ + BETTER_ENUMS__CONSTEXPR_TO_STRING_KEYWORD +# define BETTER_ENUMS__DEFAULT_DECLARE_INITIALIZE \ + BETTER_ENUMS__DO_NOT_DECLARE_INITIALIZE +# define BETTER_ENUMS__DEFAULT_DEFINE_INITIALIZE \ + BETTER_ENUMS__DO_NOT_DEFINE_INITIALIZE +# define BETTER_ENUMS__DEFAULT_CALL_INITIALIZE \ + BETTER_ENUMS__DO_NOT_CALL_INITIALIZE #else -# define _ENUM_DEFAULT_TRIM_STRINGS_ARRAYS \ - _ENUM_CXX11_PARTIAL_CONSTEXPR_TRIM_STRINGS_ARRAYS -# define _ENUM_DEFAULT_TO_STRING_KEYWORD \ - _ENUM_NO_CONSTEXPR_TO_STRING_KEYWORD -# define _ENUM_DEFAULT_DECLARE_INITIALIZE \ - _ENUM_DO_DECLARE_INITIALIZE -# define _ENUM_DEFAULT_DEFINE_INITIALIZE \ - _ENUM_DO_DEFINE_INITIALIZE -# define _ENUM_DEFAULT_CALL_INITIALIZE \ - _ENUM_DO_CALL_INITIALIZE +# define BETTER_ENUMS__DEFAULT_TRIM_STRINGS_ARRAYS \ + BETTER_ENUMS__CXX11_PARTIAL_CONSTEXPR_TRIM_STRINGS_ARRAYS +# define BETTER_ENUMS__DEFAULT_TO_STRING_KEYWORD \ + BETTER_ENUMS__NO_CONSTEXPR_TO_STRING_KEYWORD +# define BETTER_ENUMS__DEFAULT_DECLARE_INITIALIZE \ + BETTER_ENUMS__DO_DECLARE_INITIALIZE +# define BETTER_ENUMS__DEFAULT_DEFINE_INITIALIZE \ + BETTER_ENUMS__DO_DEFINE_INITIALIZE +# define BETTER_ENUMS__DEFAULT_CALL_INITIALIZE \ + BETTER_ENUMS__DO_CALL_INITIALIZE #endif #define ENUM(Enum, Integral, ...) \ - _ENUM_ID(_ENUM_TYPE( \ - _ENUM_CXX11_UNDERLYING_TYPE, \ - _ENUM_DEFAULT_SWITCH_TYPE, \ - _ENUM_DEFAULT_SWITCH_TYPE_GENERATE, \ - _ENUM_DEFAULT_TRIM_STRINGS_ARRAYS, \ - _ENUM_DEFAULT_TO_STRING_KEYWORD, \ - _ENUM_DEFAULT_DECLARE_INITIALIZE, \ - _ENUM_DEFAULT_DEFINE_INITIALIZE, \ - _ENUM_DEFAULT_CALL_INITIALIZE, \ + BETTER_ENUMS__ID(BETTER_ENUMS__TYPE( \ + BETTER_ENUMS__CXX11_UNDERLYING_TYPE, \ + BETTER_ENUMS__DEFAULT_SWITCH_TYPE, \ + BETTER_ENUMS__DEFAULT_SWITCH_TYPE_GENERATE, \ + BETTER_ENUMS__DEFAULT_TRIM_STRINGS_ARRAYS, \ + BETTER_ENUMS__DEFAULT_TO_STRING_KEYWORD, \ + BETTER_ENUMS__DEFAULT_DECLARE_INITIALIZE, \ + BETTER_ENUMS__DEFAULT_DEFINE_INITIALIZE, \ + BETTER_ENUMS__DEFAULT_CALL_INITIALIZE, \ Enum, Integral, __VA_ARGS__)) #define SLOW_ENUM(Enum, Integral, ...) \ - _ENUM_ID(_ENUM_TYPE( \ - _ENUM_CXX11_UNDERLYING_TYPE, \ - _ENUM_DEFAULT_SWITCH_TYPE, \ - _ENUM_DEFAULT_SWITCH_TYPE_GENERATE, \ - _ENUM_CXX11_FULL_CONSTEXPR_TRIM_STRINGS_ARRAYS, \ - _ENUM_CONSTEXPR_TO_STRING_KEYWORD, \ - _ENUM_DO_NOT_DECLARE_INITIALIZE, \ - _ENUM_DO_NOT_DEFINE_INITIALIZE, \ - _ENUM_DO_NOT_CALL_INITIALIZE, \ + BETTER_ENUMS__ID(BETTER_ENUMS__TYPE( \ + BETTER_ENUMS__CXX11_UNDERLYING_TYPE, \ + BETTER_ENUMS__DEFAULT_SWITCH_TYPE, \ + BETTER_ENUMS__DEFAULT_SWITCH_TYPE_GENERATE, \ + BETTER_ENUMS__CXX11_FULL_CONSTEXPR_TRIM_STRINGS_ARRAYS, \ + BETTER_ENUMS__CONSTEXPR_TO_STRING_KEYWORD, \ + BETTER_ENUMS__DO_NOT_DECLARE_INITIALIZE, \ + BETTER_ENUMS__DO_NOT_DEFINE_INITIALIZE, \ + BETTER_ENUMS__DO_NOT_CALL_INITIALIZE, \ Enum, Integral, __VA_ARGS__)) #else #define ENUM(Enum, Integral, ...) \ - _ENUM_ID(_ENUM_TYPE( \ - _ENUM_CXX98_UNDERLYING_TYPE, \ - _ENUM_DEFAULT_SWITCH_TYPE, \ - _ENUM_DEFAULT_SWITCH_TYPE_GENERATE, \ - _ENUM_CXX98_TRIM_STRINGS_ARRAYS, \ - _ENUM_NO_CONSTEXPR_TO_STRING_KEYWORD, \ - _ENUM_DO_DECLARE_INITIALIZE, \ - _ENUM_DO_DEFINE_INITIALIZE, \ - _ENUM_DO_CALL_INITIALIZE, \ + BETTER_ENUMS__ID(BETTER_ENUMS__TYPE( \ + BETTER_ENUMS__CXX98_UNDERLYING_TYPE, \ + BETTER_ENUMS__DEFAULT_SWITCH_TYPE, \ + BETTER_ENUMS__DEFAULT_SWITCH_TYPE_GENERATE, \ + BETTER_ENUMS__CXX98_TRIM_STRINGS_ARRAYS, \ + BETTER_ENUMS__NO_CONSTEXPR_TO_STRING_KEYWORD, \ + BETTER_ENUMS__DO_DECLARE_INITIALIZE, \ + BETTER_ENUMS__DO_DEFINE_INITIALIZE, \ + BETTER_ENUMS__DO_CALL_INITIALIZE, \ Enum, Integral, __VA_ARGS__)) #endif -#endif // #ifndef _BETTER_ENUMS_ENUM_H_ +#endif // #ifndef BETTER_ENUMS__ENUM_H diff --git a/script/make_macros.py b/script/make_macros.py index 0a28ecd..d9f06cb 100755 --- a/script/make_macros.py +++ b/script/make_macros.py @@ -3,18 +3,20 @@ # This file is part of Better Enums, released under the BSD 2-clause license. # See LICENSE for details, or visit http://github.com/aantron/better-enums. -# This script generates the macros _ENUM_PP_MAP and _ENUM_ITERATE, used -# internally by enum.h. These are already inlined into enum.h. You only need -# this script if you are developing enum.h, or run into a limit. +# You only need this script if you are developing enum.h, or run into a limit. # -# _ENUM_PP_MAP has a limit, which determines the maximum number of constants an -# enum can have. By default, this limit is 64 constants. +# This script generates the macros BETTER_ENUMS__PP_MAP and +# BETTER_ENUMS__ITERATE, used internally by enum.h. These are already inlined +# into enum.h. # -# _ENUM_ITERATE also has a limit. This one determines the maximum length of the -# name of a constant that is followed by an initializer (" = 2") when compiling -# an enum with constexpr to_string function (i.e. usually, this limit does not -# apply). By default, the limit is 23 characters (24 with the obligatory null -# terminator). +# BETTER_ENUMS__PP_MAP has a limit, which determines the maximum number of +# constants an enum can have. By default, this limit is 64 constants. +# +# BETTER_ENUMS__ITERATE also has a limit. This one determines the maximum length +# of the name of a constant that is followed by an initializer (" = 2") when +# compiling an enum with constexpr _to_string function (i.e. usually, this limit +# does not apply). By default, the limit is 23 characters (24 with the +# obligatory null terminator). # # If either of these limits is inadequate, you can still compile your code # without changing enum.h. You need to generate an external macro file with @@ -28,7 +30,7 @@ # 2. Build your code with an additional compiler flag: # - for gcc and clang, -DBETTER_ENUMS_MACRO_FILE='' # - for VC++, /DBETTER_ENUMS_MACRO_FILE='' -# or use any other method of getting these macros declared. +# or use any other method of getting these macros defined. # 3. Compile your code. Your macro file should be included, and enum.h should # happily work with whatever limits you chose. @@ -66,35 +68,38 @@ def generate(stream, constants, length, script): print >> stream, '' print >> stream, '#pragma once' print >> stream, '' - print >> stream, '#ifndef _BETTER_ENUM_MACRO_FILE_H_' - print >> stream, '#define _BETTER_ENUM_MACRO_FILE_H_' + print >> stream, '#ifndef BETTER_ENUMS__MACRO_FILE_H' + print >> stream, '#define BETTER_ENUMS__MACRO_FILE_H' print >> stream, '' - print >> stream, '#define _ENUM_PP_MAP(macro, data, ...) \\' - print >> stream, ' _ENUM_ID(_ENUM_A(_ENUM_PP_MAP_VAR_COUNT, ' + \ - '_ENUM_PP_COUNT(__VA_ARGS__)) \\' + print >> stream, '#define BETTER_ENUMS__PP_MAP(macro, data, ...) \\' + print >> stream, ' BETTER_ENUMS__ID( \\' + print >> stream, ' BETTER_ENUMS__APPLY( \\' + print >> stream, ' BETTER_ENUMS__PP_MAP_VAR_COUNT, \\' + print >> stream, ' BETTER_ENUMS__PP_COUNT(__VA_ARGS__)) \\' print >> stream, ' (macro, data, __VA_ARGS__))' print >> stream, '' - print >> stream, '#define _ENUM_PP_MAP_VAR_COUNT(count) ' + \ - '_ENUM_M ## count' + print >> stream, '#define BETTER_ENUMS__PP_MAP_VAR_COUNT(count) ' + \ + 'BETTER_ENUMS__M ## count' print >> stream, '' - print >> stream, '#define _ENUM_A(macro, ...) _ENUM_ID(macro(__VA_ARGS__))' + print >> stream, '#define BETTER_ENUMS__APPLY(macro, ...) ' + \ + 'BETTER_ENUMS__ID(macro(__VA_ARGS__))' print >> stream, '' - print >> stream, '#define _ENUM_ID(x) x' + print >> stream, '#define BETTER_ENUMS__ID(x) x' print >> stream, '' - print >> stream, '#define _ENUM_M1(m, d, x) m(d,0,x)' + print >> stream, '#define BETTER_ENUMS__M1(m, d, x) m(d,0,x)' for index in range(2, constants + 1): - print >> stream, '#define _ENUM_M' + str(index) + \ - '(m,d,x,...) m(d,' + str(index - 1) + \ - ',x) _ENUM_ID(_ENUM_M' + str(index - 1) + \ - '(m,d,__VA_ARGS__))' + print >> stream, '#define BETTER_ENUMS__M' + str(index) + \ + '(m,d,x,...) m(d,' + str(index - 1) + ',x) \\' + print >> stream, ' BETTER_ENUMS__ID(BETTER_ENUMS__M' + \ + str(index - 1) + '(m,d,__VA_ARGS__))' print >> stream, '' - pp_count_impl_prefix = '#define _ENUM_PP_COUNT_IMPL(_1,' + pp_count_impl_prefix = '#define BETTER_ENUMS__PP_COUNT_IMPL(_1,' stream.write(pp_count_impl_prefix) pp_count_impl = MultiLine(stream = stream, indent = 4, initial_column = len(pp_count_impl_prefix)) @@ -106,10 +111,11 @@ def generate(stream, constants, length, script): print >> stream, '' print >> stream, '' + print >> stream, '#define BETTER_ENUMS__PP_COUNT(...) \\' pp_count_prefix = \ - '#define _ENUM_PP_COUNT(...) _ENUM_ID(_ENUM_PP_COUNT_IMPL(__VA_ARGS__,' + ' BETTER_ENUMS__ID(BETTER_ENUMS__PP_COUNT_IMPL(__VA_ARGS__,' stream.write(pp_count_prefix) - pp_count = MultiLine(stream = stream, indent = 4, + pp_count = MultiLine(stream = stream, indent = 8, initial_column = len(pp_count_prefix)) for index in range(0, constants - 1): pp_count.write(' ' + str(constants - index) + ',') @@ -117,7 +123,7 @@ def generate(stream, constants, length, script): print >> stream, '' print >> stream, '' - iterate_prefix = '#define _ENUM_ITERATE(X, f, l)' + iterate_prefix = '#define BETTER_ENUMS__ITERATE(X, f, l)' stream.write(iterate_prefix) iterate = MultiLine(stream = stream, indent = 4, initial_column = len(iterate_prefix)) @@ -126,7 +132,7 @@ def generate(stream, constants, length, script): print >> stream, '' print >> stream, '' - print >> stream, '#endif // #ifndef _BETTER_ENUM_MACRO_FILE_H_' + print >> stream, '#endif // #ifndef BETTER_ENUMS__MACRO_FILE_H' if __name__ == '__main__': if len(sys.argv) != 3: