Use the standard fixed-size integer types directly

diff --git a/source/core/hash.cpp b/source/core/hash.cpp
index fe5e339c5aedc9ff0691ada988705fa0e6949898..aed9ed19d2aa522c33b9e047c1d2bca7b89e87ec 100644 (file)
--- a/source/core/hash.cpp
+++ b/source/core/hash.cpp
@@ -10,7 +10,7 @@ http://en.wikipedia.org/wiki/Fowler-Noll-Vo_hash_function
 http://www.isthe.com/chongo/tech/comp/fnv/index.html
 */
 
-UInt32 hash32(const void *data, unsigned size, unsigned bits)
+uint32_t hash32(const void *data, unsigned size, unsigned bits)
 {
        if(bits==0 || bits>32)
                throw invalid_argument("hash32");
@@ -28,15 +28,15 @@ UInt32 hash32(const void *data, unsigned size, unsigned bits)
        return result;
 }
 
-UInt64 hash64(const void *data, unsigned size, unsigned bits)
+uint64_t hash64(const void *data, unsigned size, unsigned bits)
 {
        if(bits==0 || bits>64)
                throw invalid_argument("hash64");
 
-       static const UInt64 prime = 1099511628211ULL;
-       static const UInt64 offset = 14695981039346656037ULL;
+       static const uint64_t prime = 1099511628211ULL;
+       static const uint64_t offset = 14695981039346656037ULL;
 
-       UInt64 result = offset;
+       uint64_t result = offset;
        for(unsigned i=0; i<size; ++i)
                result = (result^*(reinterpret_cast<const unsigned char *>(data)+i))*prime;
 

diff --git a/source/core/hash.h b/source/core/hash.h
index d696cae5b63542e65d6718f1012d0606b9f55833..85ee5dd74c046a4cdbc3b793cfd07d22dca2132f 100644 (file)
--- a/source/core/hash.h
+++ b/source/core/hash.h
@@ -1,8 +1,8 @@
 #ifndef MSP_CORE_HASH_H_
 #define MSP_CORE_HASH_H_
 
+#include <cstdint>
 #include <string>
-#include "inttypes.h"
 
 namespace Msp {
 
@@ -11,7 +11,7 @@ Computes a 32-bit Fowler-Noll-Vo (FNV-1a) hash.  The number of bits can be
 limited to less than 32, in which case XOR-folding is used to reduce the hash
 size.
 */
-UInt32 hash32(const void *, unsigned, unsigned = 32);
+std::uint32_t hash32(const void *, unsigned, unsigned = 32);
 
 /**
 Convenience function to compute a 32-bit hash of a string.
@@ -23,18 +23,18 @@ inline unsigned hash32(const std::string &s, unsigned b = 32)
 Computes a 64-bit Fowler-Noll-Vo (FNV-1a) hash.  Note that even if bits is
 limited to 32 or less, this does not produce the same result as hash32.
 */
-UInt64 hash64(const void *, unsigned, unsigned = 64);
+std::uint64_t hash64(const void *, unsigned, unsigned = 64);
 
 /**
 Convenience function to compute a 64-bit hash of a string.
 */
-inline UInt64 hash64(const std::string &s, unsigned b = 64)
+inline std::uint64_t hash64(const std::string &s, unsigned b = 64)
 { return hash64(s.data(), s.size(), b); }
 
-inline UInt32 fold32(UInt64 hash)
+inline std::uint32_t fold32(std::uint64_t hash)
 { return hash^(hash>>32); }
 
-inline UInt16 fold16(UInt64 hash)
+inline std::uint16_t fold16(std::uint64_t hash)
 { return hash^(hash>>16)^(hash>>32)^(hash>>48); }
 
 } // namespace Msp

diff --git a/source/fs/stat.h b/source/fs/stat.h
index 3f056a5609eea802716037eb734c3d42ef51905d..e2400ed9b5a037b2a4396aa92d0fb92e01009118 100644 (file)
--- a/source/fs/stat.h
+++ b/source/fs/stat.h
@@ -1,8 +1,8 @@
 #ifndef MSP_FS_STAT_H_
 #define MSP_FS_STAT_H_
 
+#include <cstdint>
 #include <string>
-#include <msp/core/inttypes.h>
 #include <msp/time/timestamp.h>
 #include "path.h"
 
@@ -17,7 +17,7 @@ enum FileType
        SYMLINK
 };
 
-typedef UInt64 FileSize;
+typedef uint64_t FileSize;
 
 /**
 Holds file information.

diff --git a/source/io/seekable.h b/source/io/seekable.h
index f0170b40f5af126de2c641431d7a2033cc1f1415..99915d850efc3a8879d88a7e9e3e9de7e11eb531 100644 (file)
--- a/source/io/seekable.h
+++ b/source/io/seekable.h
@@ -1,8 +1,8 @@
 #ifndef MSP_IO_SEEKABLE_H_
 #define MSP_IO_SEEKABLE_H_
 
+#include <cstdint>
 #include <stdexcept>
-#include <msp/core/inttypes.h>
 #include "base.h"
 
 namespace Msp {
@@ -10,7 +10,7 @@ namespace IO {
 
 class Handle;
 
-typedef Int64 SeekOffset;
+typedef std::int64_t SeekOffset;
 
 enum SeekType
 {

diff --git a/source/strings/lexicalcast.cpp b/source/strings/lexicalcast.cpp
index 2c867b2ce0572b7489a7fb6c9e74013efb6b7804..2b84d9bbbcdaa4e93af36d15d6bb5063807f7ef6 100644 (file)
--- a/source/strings/lexicalcast.cpp
+++ b/source/strings/lexicalcast.cpp
@@ -1,6 +1,6 @@
 #include <cmath>
+#include <cstdint>
 #include <limits>
-#include <msp/core/inttypes.h>
 #include "format.h"
 #include "lexicalcast.h"
 
@@ -557,7 +557,7 @@ void operator<<(LexicalConverter &c, const char *s)
 { c.result(str_to_str(s, c.get_fmt())); }
 
 void operator<<(LexicalConverter &c, const void *p)
-{ c.result(int_to_str(reinterpret_cast<IntPtr>(p), c.get_fmt())); }
+{ c.result(int_to_str(reinterpret_cast<intptr_t>(p), c.get_fmt())); }
 
 
 /*** operator>> ***/

diff --git a/source/time/rawtime.h b/source/time/rawtime.h
index 1af7956f25c09a5bb0103cb3e8f1b08b3094fbef..46b3e4df6908ec3c49e93752da2a3a0668e3b3dc 100644 (file)
--- a/source/time/rawtime.h
+++ b/source/time/rawtime.h
@@ -1,12 +1,12 @@
 #ifndef MSP_TIME_RAWTIME_H_
 #define MSP_TIME_RAWTIME_H_
 
-#include <msp/core/inttypes.h>
+#include <cstdint>
 
 namespace Msp {
 namespace Time {
 
-typedef Int64 RawTime;
+typedef std::int64_t RawTime;
 
 } // namespace Time
 } // namespace Msp