From 561d8f707015414638f98f55f0103b5a82859ca5 Mon Sep 17 00:00:00 2001 From: Beman Date: Sat, 15 Nov 2014 08:02:08 -0500 Subject: [PATCH] Initial commit buffers.hpp and related infrastructure. A separate buffer class without arithmetic operators was requested during the formal review. --- include/boost/endian/buffers.hpp | 602 ++++++++++++++++++++++ test/buffer_test.cpp | 46 ++ test/msvc/buffer_test/buffer_test.vcxproj | 88 ++++ test/msvc/endian.sln | 12 +- 4 files changed, 747 insertions(+), 1 deletion(-) create mode 100644 include/boost/endian/buffers.hpp create mode 100644 test/buffer_test.cpp create mode 100644 test/msvc/buffer_test/buffer_test.vcxproj diff --git a/include/boost/endian/buffers.hpp b/include/boost/endian/buffers.hpp new file mode 100644 index 0000000..d8aba87 --- /dev/null +++ b/include/boost/endian/buffers.hpp @@ -0,0 +1,602 @@ +// boost/endian/types.hpp ------------------------------------------------------------// + +// (C) Copyright Darin Adler 2000 +// (C) Copyright Beman Dawes 2006, 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// See library home page at http://www.boost.org/libs/endian + +//--------------------------------------------------------------------------------------// + +// Original design developed by Darin Adler based on classes developed by Mark +// Borgerding. Four original class templates were combined into a single endian +// class template by Beman Dawes, who also added the unrolled_byte_loops sign +// partial specialization to correctly extend the sign when cover integer size +// differs from endian representation size. + +// TODO: When a compiler supporting constexpr becomes available, try possible uses. + +#ifndef BOOST_ENDIAN_BUFFERS_HPP +#define BOOST_ENDIAN_BUFFERS_HPP + +#if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable:4365) // conversion ... signed/unsigned mismatch +#endif + +#ifdef BOOST_ENDIAN_LOG +# include +#endif + +#if defined(__BORLANDC__) || defined( __CODEGEARC__) +# pragma pack(push, 1) +#endif + +#include +#include +#include +#define BOOST_MINIMAL_INTEGER_COVER_OPERATORS +#include +#undef BOOST_MINIMAL_INTEGER_COVER_OPERATORS +#include +#include +#include +#include +#include +#include + +# if CHAR_BIT != 8 +# error Platforms with CHAR_BIT != 8 are not supported +# endif + +# ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS +# define BOOST_ENDIAN_DEFAULT_CONSTRUCT {} // C++03 +# else +# define BOOST_ENDIAN_DEFAULT_CONSTRUCT = default; // C++0x +# endif + +# if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && defined(BOOST_ENDIAN_FORCE_PODNESS) +# define BOOST_ENDIAN_NO_CTORS +# endif + +# ifndef BOOST_ENDIAN_EXPLICIT_CTORS +# define BOOST_ENDIAN_EXPLICIT_OPT +# else +# define BOOST_ENDIAN_EXPLICIT_OPT explicit +# endif + +//---------------------------------- synopsis ----------------------------------------// + +namespace boost +{ +namespace endian +{ + +#ifndef BOOST_ENDIAN_ORDER_ENUM_DEFINED + BOOST_SCOPED_ENUM_START(order) + { + big, little, +# ifdef BOOST_BIG_ENDIAN + native = big +# else + native = little +# endif + }; BOOST_SCOPED_ENUM_END +# define BOOST_ENDIAN_ORDER_ENUM_DEFINED +#endif + BOOST_SCOPED_ENUM_START(align) {no, yes}; BOOST_SCOPED_ENUM_END + + template + class endian_buffer; + + // aligned big endian floating point types + typedef endian_buffer big_align_floatbuf32_t; + typedef endian_buffer big_align_floatbuf64_t; + + // aligned little endian floating point types + typedef endian_buffer little_align_floatbuf32_t; + typedef endian_buffer little_align_floatbuf64_t; + + // unaligned big endian floating point types + typedef endian_buffer big_floatbuf32_t; + typedef endian_buffer big_floatbuf64_t; + + // unaligned little endian floating point types + typedef endian_buffer little_floatbuf32_t; + typedef endian_buffer little_floatbuf64_t; + + // aligned big endian signed integer types + typedef endian_buffer big_align_buf16_t; + typedef endian_buffer big_align_buf32_t; + typedef endian_buffer big_align_buf64_t; + + // aligned big endian unsigned integer types + typedef endian_buffer big_align_ubuf16_t; + typedef endian_buffer big_align_ubuf32_t; + typedef endian_buffer big_align_ubuf64_t; + + // aligned little endian signed integer types + typedef endian_buffer little_align_buf16_t; + typedef endian_buffer little_align_buf32_t; + typedef endian_buffer little_align_buf64_t; + + // aligned little endian unsigned integer types + typedef endian_buffer little_align_ubuf16_t; + typedef endian_buffer little_align_ubuf32_t; + typedef endian_buffer little_align_ubuf64_t; + + // aligned native endian typedefs are not provided because + // types are superior for this use case + + // unaligned big endian signed integer types + typedef endian_buffer big_buf8_t; + typedef endian_buffer big_buf16_t; + typedef endian_buffer big_buf24_t; + typedef endian_buffer big_buf32_t; + typedef endian_buffer big_buf40_t; + typedef endian_buffer big_buf48_t; + typedef endian_buffer big_buf56_t; + typedef endian_buffer big_buf64_t; + + // unaligned big endian unsigned integer types + typedef endian_buffer big_ubuf8_t; + typedef endian_buffer big_ubuf16_t; + typedef endian_buffer big_ubuf24_t; + typedef endian_buffer big_ubuf32_t; + typedef endian_buffer big_ubuf40_t; + typedef endian_buffer big_ubuf48_t; + typedef endian_buffer big_ubuf56_t; + typedef endian_buffer big_ubuf64_t; + + // unaligned little endian signed integer types + typedef endian_buffer little_buf8_t; + typedef endian_buffer little_buf16_t; + typedef endian_buffer little_buf24_t; + typedef endian_buffer little_buf32_t; + typedef endian_buffer little_buf40_t; + typedef endian_buffer little_buf48_t; + typedef endian_buffer little_buf56_t; + typedef endian_buffer little_buf64_t; + + // unaligned little endian unsigned integer types + typedef endian_buffer little_ubuf8_t; + typedef endian_buffer little_ubuf16_t; + typedef endian_buffer little_ubuf24_t; + typedef endian_buffer little_ubuf32_t; + typedef endian_buffer little_ubuf40_t; + typedef endian_buffer little_ubuf48_t; + typedef endian_buffer little_ubuf56_t; + typedef endian_buffer little_ubuf64_t; + +# ifdef BOOST_BIG_ENDIAN + // unaligned native endian signed integer types + typedef big_buf8_t native_buf8_t; + typedef big_buf16_t native_buf16_t; + typedef big_buf24_t native_buf24_t; + typedef big_buf32_t native_buf32_t; + typedef big_buf40_t native_buf40_t; + typedef big_buf48_t native_buf48_t; + typedef big_buf56_t native_buf56_t; + typedef big_buf64_t native_buf64_t; + + // unaligned native endian unsigned integer types + typedef big_ubuf8_t native_ubuf8_t; + typedef big_ubuf16_t native_ubuf16_t; + typedef big_ubuf24_t native_ubuf24_t; + typedef big_ubuf32_t native_ubuf32_t; + typedef big_ubuf40_t native_ubuf40_t; + typedef big_ubuf48_t native_ubuf48_t; + typedef big_ubuf56_t native_ubuf56_t; + typedef big_ubuf64_t native_ubuf64_t; + + // native endian floating point types + typedef big_floatbuf32_t native_floatbuf32_t; + typedef big_floatbuf64_t native_floatbuf64_t; + typedef big_align_floatbuf32_t native_align_floatbuf32_t; + typedef big_align_floatbuf64_t native_align_floatbuf64_t; +# else + // unaligned native endian signed integer types + typedef little_buf8_t native_buf8_t; + typedef little_buf16_t native_buf16_t; + typedef little_buf24_t native_buf24_t; + typedef little_buf32_t native_buf32_t; + typedef little_buf40_t native_buf40_t; + typedef little_buf48_t native_buf48_t; + typedef little_buf56_t native_buf56_t; + typedef little_buf64_t native_buf64_t; + + // unaligned native endian unsigned integer types + typedef little_ubuf8_t native_ubuf8_t; + typedef little_ubuf16_t native_ubuf16_t; + typedef little_ubuf24_t native_ubuf24_t; + typedef little_ubuf32_t native_ubuf32_t; + typedef little_ubuf40_t native_ubuf40_t; + typedef little_ubuf48_t native_ubuf48_t; + typedef little_ubuf56_t native_ubuf56_t; + typedef little_ubuf64_t native_ubuf64_t; + + // native endian floating point types + typedef little_floatbuf32_t native_floatbuf32_t; + typedef little_floatbuf64_t native_floatbuf64_t; + typedef little_align_floatbuf32_t native_align_floatbuf32_t; + typedef little_align_floatbuf64_t native_align_floatbuf64_t; +# endif +} // namespace boost +} // namespace endian + +//---------------------------------- end synopsis ------------------------------------// + +namespace boost +{ +namespace endian +{ + namespace detail + { + + // Unrolled loops for loading and storing streams of bytes. + + template ::value > + struct unrolled_byte_loops + { + typedef unrolled_byte_loops next; + + static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT + { return *(bytes - 1) | (next::load_big(bytes - 1) << 8); } + static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT + { return *bytes | (next::load_little(bytes + 1) << 8); } + + static void store_big(char* bytes, T value) BOOST_NOEXCEPT + { + *(bytes - 1) = static_cast(value); + next::store_big(bytes - 1, value >> 8); + } + static void store_little(char* bytes, T value) BOOST_NOEXCEPT + { + *bytes = static_cast(value); + next::store_little(bytes + 1, value >> 8); + } + }; + + template + struct unrolled_byte_loops + { + static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT + { return *(bytes - 1); } + static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT + { return *bytes; } + static void store_big(char* bytes, T value) BOOST_NOEXCEPT + { *(bytes - 1) = static_cast(value); } + static void store_little(char* bytes, T value) BOOST_NOEXCEPT + { *bytes = static_cast(value); } + + }; + + template + struct unrolled_byte_loops + { + static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT + { return *reinterpret_cast(bytes - 1); } + static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT + { return *reinterpret_cast(bytes); } + static void store_big(char* bytes, T value) BOOST_NOEXCEPT + { *(bytes - 1) = static_cast(value); } + static void store_little(char* bytes, T value) BOOST_NOEXCEPT + { *bytes = static_cast(value); } + }; + + template + inline + T load_big_endian(const void* bytes) BOOST_NOEXCEPT + { + return unrolled_byte_loops::load_big + (static_cast(bytes) + n_bytes); + } + + template + inline + T load_little_endian(const void* bytes) BOOST_NOEXCEPT + { + return unrolled_byte_loops::load_little + (static_cast(bytes)); + } + + template + inline + void store_big_endian(void* bytes, T value) BOOST_NOEXCEPT + { + unrolled_byte_loops::store_big + (static_cast(bytes) + n_bytes, value); + } + + template + inline + void store_little_endian(void* bytes, T value) BOOST_NOEXCEPT + { + unrolled_byte_loops::store_little + (static_cast(bytes), value); + } + + } // namespace detail + +# ifdef BOOST_ENDIAN_LOG + bool endian_log(true); +# endif + +// endian_buffer class template specializations --------------------------------------// + + // Specializations that represent unaligned bytes. + // Taking an integer type as a parameter provides a nice way to pass both + // the size and signedness of the desired integer and get the appropriate + // corresponding integer type for the interface. + + // unaligned big endian_buffer specialization + template + class endian_buffer< order::big, T, n_bits, align::no > + { + BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); + public: + typedef T value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_buffer(T val) BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "big, unaligned, " + << n_bits << "-bits, construct(" << val << ")\n"; +# endif + detail::store_big_endian(m_value, val); + } +# endif + endian_buffer & operator=(T val) BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if (endian_log) + std::cout << "big, unaligned, " << n_bits << "-bits, assign(" << val << ")\n"; +# endif + detail::store_big_endian(m_value, val); + return *this; + } + operator T() const BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "big, unaligned, " << n_bits << "-bits, convert(" + << detail::load_big_endian(m_value) << ")\n"; +# endif + return detail::load_big_endian(m_value); + } + const char* data() const BOOST_NOEXCEPT { return m_value; } + private: + char m_value[n_bits/8]; + }; + + // unaligned float big endian_buffer specialization + template <> + class endian_buffer< order::big, float, 32, align::no > + { + public: + typedef float value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_buffer(value_type val) BOOST_NOEXCEPT + { detail::big_reverse_copy(val, m_value); } +# endif + endian_buffer & operator=(value_type val) BOOST_NOEXCEPT + { detail::big_reverse_copy(val, m_value); return *this; } + operator value_type() const BOOST_NOEXCEPT + { + value_type tmp; + detail::big_reverse_copy(m_value, tmp); + return tmp; + } + const char* data() const BOOST_NOEXCEPT { return m_value; } + private: + char m_value[sizeof(value_type)]; + }; + + // unaligned double big endian_buffer specialization + template <> + class endian_buffer< order::big, double, 64, align::no > + { + public: + typedef double value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_buffer(value_type val) BOOST_NOEXCEPT + { detail::big_reverse_copy(val, m_value); } +# endif + endian_buffer & operator=(value_type val) BOOST_NOEXCEPT + { detail::big_reverse_copy(val, m_value); return *this; } + operator value_type() const BOOST_NOEXCEPT + { + value_type tmp; + detail::big_reverse_copy(m_value, tmp); + return tmp; + } + const char* data() const BOOST_NOEXCEPT { return m_value; } + private: + char m_value[sizeof(value_type)]; + }; + + // unaligned float little endian_buffer specialization + template <> + class endian_buffer< order::little, float, 32, align::no > + { + public: + typedef float value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_buffer(value_type val) BOOST_NOEXCEPT + { detail::little_reverse_copy(val, m_value); } +# endif + endian_buffer & operator=(value_type val) BOOST_NOEXCEPT + { detail::little_reverse_copy(val, m_value); return *this; } + operator value_type() const BOOST_NOEXCEPT + { + value_type tmp; + detail::little_reverse_copy(m_value, tmp); + return tmp; + } + const char* data() const BOOST_NOEXCEPT { return m_value; } + private: + char m_value[sizeof(value_type)]; + }; + + // unaligned double little endian_buffer specialization + template <> + class endian_buffer< order::little, double, 64, align::no > + { + public: + typedef double value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_buffer(value_type val) BOOST_NOEXCEPT + { detail::little_reverse_copy(val, m_value); } +# endif + endian_buffer & operator=(value_type val) BOOST_NOEXCEPT + { detail::little_reverse_copy(val, m_value); return *this; } + operator value_type() const BOOST_NOEXCEPT + { + value_type tmp; + detail::little_reverse_copy(m_value, tmp); + return tmp; + } + const char* data() const BOOST_NOEXCEPT { return m_value; } + private: + char m_value[sizeof(value_type)]; + }; + + // unaligned little endian_buffer specialization + template + class endian_buffer< order::little, T, n_bits, align::no > + { + BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); + public: + typedef T value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_buffer(T val) BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "little, unaligned, " << n_bits << "-bits, construct(" + << val << ")\n"; +# endif + detail::store_little_endian(m_value, val); + } +# endif + endian_buffer & operator=(T val) BOOST_NOEXCEPT + { detail::store_little_endian(m_value, val); return *this; } + operator T() const BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "little, unaligned, " << n_bits << "-bits, convert(" + << detail::load_little_endian(m_value) << ")\n"; +# endif + return detail::load_little_endian(m_value); + } + const char* data() const BOOST_NOEXCEPT { return m_value; } + private: + char m_value[n_bits/8]; + }; + + // align::yes specializations; only n_bits == 16/32/64 supported + + // aligned big endian_buffer specialization + template + class endian_buffer + { + BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); + BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 ); + public: + typedef T value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_buffer(T val) BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "big, aligned, " << n_bits + << "-bits, construct(" << val << ")\n"; +# endif + m_value = ::boost::endian_buffer::big_endian_value(val); + } + +# endif + endian_buffer& operator=(T val) BOOST_NOEXCEPT + { + m_value = ::boost::endian_buffer::big_endian_value(val); + return *this; + } + operator T() const BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "big, aligned, " << n_bits << "-bits, convert(" + << ::boost::endian_buffer::big_endian_value(m_value) << ")\n"; +# endif + return ::boost::endian_buffer::big_endian_value(m_value); + } + const char* data() const BOOST_NOEXCEPT {return reinterpret_cast(&m_value);} + private: + T m_value; + }; + + // aligned little endian_buffer specialization + template + class endian_buffer + { + BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); + BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 ); + public: + typedef T value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_buffer(T val) BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "little, aligned, " << n_bits + << "-bits, construct(" << val << ")\n"; +# endif + m_value = ::boost::endian_buffer::little_endian_value(val); + } + +# endif + endian_buffer& operator=(T val) BOOST_NOEXCEPT + { + m_value = ::boost::endian_buffer::little_endian_value(val); + return *this; + } + operator T() const BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "little, aligned, " << n_bits << "-bits, convert(" + << ::boost::endian_buffer::little_endian_value(m_value) << ")\n"; +# endif + return ::boost::endian_buffer::little_endian_value(m_value); + } + const char* data() const BOOST_NOEXCEPT {return reinterpret_cast(&m_value);} + private: + T m_value; + }; + +} // namespace endian +} // namespace boost + +#if defined(__BORLANDC__) || defined( __CODEGEARC__) +# pragma pack(pop) +#endif + +#if defined(_MSC_VER) +# pragma warning(pop) +#endif + +#endif // BOOST_ENDIAN_BUFFERS_HPP diff --git a/test/buffer_test.cpp b/test/buffer_test.cpp new file mode 100644 index 0000000..7411b4e --- /dev/null +++ b/test/buffer_test.cpp @@ -0,0 +1,46 @@ +// buffer_test.cpp -------------------------------------------------------------------// + +// Copyright Beman Dawes 2014 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// See library home page at http://www.boost.org/libs/endian + +//--------------------------------------------------------------------------------------// + +#define _SCL_SECURE_NO_WARNINGS + +#include + +#define BOOST_ENDIAN_LOG +#include +#include +#include +#include + +namespace bel = boost::endian; +using std::cout; +using std::endl; + + +int cpp_main(int, char *[]) +{ + cout << "byte swap intrinsics: " BOOST_ENDIAN_INTRINSIC_MSG << endl; + + cout << " construct" << endl; + bel::big_buf32_t x(1122334455); + + cout << " assign from built-in integer" << endl; + x = 1234567890; + + cout << " operator==(buffer, built-in)" << endl; + bool b1(x == 1234567890); + + // BOOST_TEST(x == 1234567890); + cout << " done" << endl; + + return ::boost::report_errors(); +} + +#include diff --git a/test/msvc/buffer_test/buffer_test.vcxproj b/test/msvc/buffer_test/buffer_test.vcxproj new file mode 100644 index 0000000..5505bfe --- /dev/null +++ b/test/msvc/buffer_test/buffer_test.vcxproj @@ -0,0 +1,88 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {BFB68CF4-EB92-4E5C-9694-A939496C5CDE} + Win32Proj + buffer_test + + + + Application + true + v140 + Unicode + + + Application + false + v140 + true + Unicode + + + + + + + + + + + + + + + true + + + false + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/test/msvc/endian.sln b/test/msvc/endian.sln index 3270d8b..11ac095 100644 --- a/test/msvc/endian.sln +++ b/test/msvc/endian.sln @@ -1,6 +1,8 @@  Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio Express 2012 for Windows Desktop +# Visual Studio 14 +VisualStudioVersion = 14.0.22310.1 +MinimumVisualStudioVersion = 10.0.40219.1 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "endian_test", "endian_test\endian_test.vcxproj", "{74C201F3-8308-40BE-BC0F-24974DEAF405}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "endian_in_union_test", "endian_in_union_test\endian_in_union_test.vcxproj", "{3926C6DC-9D1E-4227-BEF5-81F5EC621A75}" @@ -23,6 +25,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "speed_test", "speed_test\sp EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "loop_time_test", "loop_time_test\loop_time_test.vcxproj", "{541A2D06-B34E-4592-BE47-F87DF47E73D8}" EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "buffer_test", "buffer_test\buffer_test.vcxproj", "{BFB68CF4-EB92-4E5C-9694-A939496C5CDE}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Win32 = Debug|Win32 @@ -115,6 +119,12 @@ Global {541A2D06-B34E-4592-BE47-F87DF47E73D8}.Release|Win32.Build.0 = Release|Win32 {541A2D06-B34E-4592-BE47-F87DF47E73D8}.Release|x64.ActiveCfg = Release|x64 {541A2D06-B34E-4592-BE47-F87DF47E73D8}.Release|x64.Build.0 = Release|x64 + {BFB68CF4-EB92-4E5C-9694-A939496C5CDE}.Debug|Win32.ActiveCfg = Debug|Win32 + {BFB68CF4-EB92-4E5C-9694-A939496C5CDE}.Debug|Win32.Build.0 = Debug|Win32 + {BFB68CF4-EB92-4E5C-9694-A939496C5CDE}.Debug|x64.ActiveCfg = Debug|Win32 + {BFB68CF4-EB92-4E5C-9694-A939496C5CDE}.Release|Win32.ActiveCfg = Release|Win32 + {BFB68CF4-EB92-4E5C-9694-A939496C5CDE}.Release|Win32.Build.0 = Release|Win32 + {BFB68CF4-EB92-4E5C-9694-A939496C5CDE}.Release|x64.ActiveCfg = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE