Use integer types from <cstdint>
authorMikko Rasa <tdb@tdb.fi>
Sun, 29 Aug 2021 10:06:40 +0000 (13:06 +0300)
committerMikko Rasa <tdb@tdb.fi>
Sun, 29 Aug 2021 22:42:03 +0000 (01:42 +0300)
source/core/inttypes.h
source/core/typelist.h [deleted file]
source/fs/unix/filemonitor.cpp
source/strings/lexicalcast.cpp

index c0af5ca9f2d2cf485b7a84d56285835087e3119c..68b870cc97a3890ef23bb1948458c5df08351882 100644 (file)
@@ -1,70 +1,20 @@
 #ifndef MSP_CORE_INTTYPES_H_
 #define MSP_CORE_INTTYPES_H_
 
-#include <climits>
-#include "typelist.h"
+#include <cstdint>
 
 namespace Msp {
 
-// Define lists of standard types, both signed and unsigned variants
-typedef TypeList<signed char, short, int, long>::Type StandardSignedTypes;
-typedef TypeList<unsigned char, unsigned short, unsigned int, unsigned long>::Type StandardUnsignedTypes;
-
-// Then add possible nonstandard types
-#if defined(__GNUC__)
-#if (__GNUC__>4 || (__GNUC__==4 && __GNUC_MINOR__>=6)) && defined(__LP64__)
-#pragma GCC diagnostic push
-#if __GNUC__>=5
-#pragma GCC diagnostic ignored "-Wpedantic"
-#else
-#pragma GCC diagnostic ignored "-pedantic"
-#endif
-typedef TypeList<StandardSignedTypes, long long, __int128>::Type PlatformSignedTypes;
-typedef TypeList<StandardUnsignedTypes, unsigned long long, unsigned __int128>::Type PlatformUnsignedTypes;
-#pragma GCC diagnostic pop
-#else
-typedef TypeList<StandardSignedTypes, long long>::Type PlatformSignedTypes;
-typedef TypeList<StandardUnsignedTypes, unsigned long long>::Type PlatformUnsignedTypes;
-#endif
-#elif defined(_MSC_VER)
-typedef TypeList<StandardSignedTypes, __int64>::Type PlatformSignedTypes;
-typedef TypeList<StandardUnsignedTypes, unsigned __int64>::Type PlatformUnsignedTypes;
-#else
-typedef StandardSignedTypes PlatformSignedTypes;
-typedef StandardUnsignedTypes PlatformUnsignedTypes;
-#endif
-
-/** A helper for choosing an integer type of a specific size.  The size
-parameter is in bits.  The resulting types can be obtained from the SignedType
-and UnsignedType typedefs. */
-template<unsigned size>
-struct Int
-{
-       template<typename T>
-       struct Predicate
-       {
-               enum { value = (sizeof(T)*CHAR_BIT==size) };
-       };
-
-       typedef typename TypeChooser<PlatformSignedTypes, Predicate>::Type SignedType;
-       typedef typename TypeChooser<PlatformUnsignedTypes, Predicate>::Type UnsignedType;
-};
-
-/** A helper for choosing an integer that's the same size as another type. */
-template<typename T>
-struct MatchingInt: Int<sizeof(T)*CHAR_BIT>
-{ };
-
-// Finally define convenient shorthands for the actual integer types
-typedef Int<8>::SignedType Int8;
-typedef Int<8>::UnsignedType UInt8;
-typedef Int<16>::SignedType Int16;
-typedef Int<16>::UnsignedType UInt16;
-typedef Int<32>::SignedType Int32;
-typedef Int<32>::UnsignedType UInt32;
-typedef Int<64>::SignedType Int64;
-typedef Int<64>::UnsignedType UInt64;
-typedef MatchingInt<void *>::UnsignedType IntPtr;
+// These typedefs will be deprecated at some point
+typedef std::int8_t Int8;
+typedef std::uint8_t UInt8;
+typedef std::int16_t Int16;
+typedef std::uint16_t UInt16;
+typedef std::int32_t Int32;
+typedef std::uint32_t UInt32;
+typedef std::int64_t Int64;
+typedef std::uint64_t UInt64;
+typedef std::intptr_t IntPtr;
 
 } // namespace Msp
 
diff --git a/source/core/typelist.h b/source/core/typelist.h
deleted file mode 100644 (file)
index ecc28fa..0000000
+++ /dev/null
@@ -1,130 +0,0 @@
-#ifndef MSP_CORE_TYPELIST_H_
-#define MSP_CORE_TYPELIST_H_
-
-namespace Msp {
-
-/** Sentinel type for type lists */
-struct NullType { };
-
-
-/** A "cons cell" for types.  Composed of a head and a tail.  To construct
-longer lists, use another TypeCons as the tail.  The tail of the last TypeCons
-should by NullType. */
-template<typename H, typename T>
-struct TypeCons
-{
-       typedef H Head;
-       typedef T Tail;
-};
-
-
-/** Basic terminated type list of one element. */
-template<typename T1>
-struct TypeList1
-{
-       typedef TypeCons<T1, NullType> Type;
-};
-
-/** Specialization to avoid creating a TypeCons with two NullTypes. */
-template<>
-struct TypeList1<NullType>
-{
-       typedef NullType Type;
-};
-
-/** Specialization to avoid creating a TypeCons with another TypeCons as its
-head. */
-template<typename T1, typename T2>
-struct TypeList1<TypeCons<T1, T2> >
-{
-       typedef TypeCons<T1, T2> Type;
-};
-
-/** Basic terminated type list of two elements. */
-template<typename T1, typename T2>
-struct TypeList2
-{
-       typedef TypeCons<T1, typename TypeList1<T2>::Type> Type;
-};
-
-/** Specialization to ignore an initial NullType. */
-template<typename T1>
-struct TypeList2<NullType, T1>
-{
-       typedef typename TypeList1<T1>::Type Type;
-};
-
-/** Specialization to flatten an initial TypeCons. */
-template<typename T1, typename T2, typename T3>
-struct TypeList2<TypeCons<T1, T2>, T3>
-{
-       typedef typename TypeList2<T1, typename TypeList2<T2, T3>::Type>::Type Type;
-};
-
-
-/** A terminated type list of five elements.  Use the typedef Type inside to
-obtain the actual list type.  If any of the types is a type list itself, the
-entire structure is flattened to a single list. */
-template<typename T1, typename T2 = NullType, typename T3 = NullType, typename T4 = NullType, typename T5 = NullType>
-struct TypeList
-{
-       typedef typename TypeList<T1, typename TypeList<T2, T3, T4, T5>::Type>::Type Type;
-};
-
-/** Specialization of TypeList for one element. */
-template<typename T1>
-struct TypeList<T1, NullType, NullType, NullType, NullType>
-{
-       typedef typename TypeList1<T1>::Type Type;
-};
-
-/** Specialization of TypeList for two elements. */
-template<typename T1, typename T2>
-struct TypeList<T1, T2, NullType, NullType, NullType>
-{
-       typedef typename TypeList2<T1, T2>::Type Type;
-};
-
-/** Specialization of TypeList for three elements. */
-template<typename T1, typename T2, typename T3>
-struct TypeList<T1, T2, T3, NullType, NullType>
-{
-       typedef typename TypeList<T1, typename TypeList<T2, T3>::Type>::Type Type;
-};
-
-/** Specialization of TypeList for four elements. */
-template<typename T1, typename T2, typename T3, typename T4>
-struct TypeList<T1, T2, T3, T4, NullType>
-{
-       typedef typename TypeList<T1, typename TypeList<T2, T3, T4>::Type>::Type Type;
-};
-
-
-/** A helper for selecting a type from a list based on a predicate.  The
-predicate should be a template taking a single type argument and defining a
-compile-time constant with the name "value", which evaluates to true if the
-type is considered a match.  The result can be obtained from the member
-typedef Type.  If the list contains no matching type, an ugly and confusing
-compiler error will result. */
-template<typename L, template<typename> class P, bool f = P<typename L::Head>::value>
-struct TypeChooser;
-
-/** Specialization for a matching type.  Picks the head of the list as the
-result. */
-template<typename L, template<typename> class P>
-struct TypeChooser<L, P, true>
-{
-       typedef typename L::Head Type;
-};
-
-/** Specialization for a non-matchin type.  Recursively inspects the tail of
-the list. */
-template<typename L, template<typename> class P>
-struct TypeChooser<L, P, false>
-{
-       typedef typename TypeChooser<typename L::Tail, P>::Type Type;
-};
-
-} // namespace Msp
-
-#endif
index 68cd7aebda419752bfcab37f51f451421a185049..e2ca3b74ebcde44bcc85f562e67ea20d989074a4 100644 (file)
@@ -1,4 +1,5 @@
 #include <sys/inotify.h>
+#include <linux/limits.h>
 #include <msp/core/systemerror.h>
 #include <msp/io/handle_private.h>
 #include "filemonitor.h"
index 8789544bbb355f14f421ccd9a6ea5f761a25e256..f5b3a95ee9af7ea0db2e1865b709dadf77dbf1de 100644 (file)
@@ -59,7 +59,7 @@ char *int_to_str(T v, const Fmt &f, char *end)
        const char *digits = (f.get_uppercase() ? udigits : ldigits);
        if(v)
        {
-               typename MatchingInt<T>::UnsignedType w = Absolute<T>::eval(v);
+               typename std::make_unsigned<T>::type w = Absolute<T>::eval(v);
                while(w)
                {
                        *--ptr = digits[w%base];