boostorg/endian
1
0
Fork 1
mirror of https://github.com/boostorg/endian.git synced 2025-07-31 13:07:24 +02:00
Code Issues Packages Projects Releases Wiki Activity

Fix boo boos detected by inspect program.

Browse Source
This commit is contained in:
Beman
2013-05-29 09:40:35 -04:00
parent 457ed73778
commit db3864b3d4
5 changed files with 49 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
doc/conversion.html
View File

@ -174,7 +174,7 @@ type (possibly <code>const</code>) <code>ReversibleValue</code>.</p>
<td valign="top">
<p><code>reverse_value(x)</code></td>
<td valign="top">
<p><a name="ReversibleValue"><code>ReversibleValue</code></a></td>
<p><code>ReversibleValue</code></td>
<td>
<p>The returned value is the value of <code>x</code> with the
order of its constituent bytes reversed.</td>

7
doc/types.html
View File

@ -50,8 +50,7 @@
<a href="#Example">Example</a><br>
<a href="#Limitations">Limitations</a><br>
<a href="#Feature-set">Feature set</a><br>
<a href="#Types">Typedefs</a><br>
&nbsp;&nbsp;&nbsp; <a href="#Comment-on-naming">Comment on naming</a><br>
<a href="#Types">Enums and typedefs</a><br>
<a href="#Class_template_endian">Class template <code>endian</code></a><br>
&nbsp;&nbsp;&nbsp;
<a href="#Synopsis">Synopsis</a><br>
@ -172,7 +171,7 @@ int main(int, char* [])
}
</pre>
</blockquote>
<p>After compiling and executing <a href="endian_example.cpp">endian_example.cpp</a>,
<p>After compiling and executing <a href="../example/endian_example.cpp">endian_example.cpp</a>,
a hex dump of <code>test.dat</code> shows:</p>
<blockquote>
<pre>01020304 00000010 01000000 04030201</pre>
@ -617,7 +616,7 @@ differs from endian representation size. Vicente Botet and other reviewers
suggested supporting floating point types.</p>
<hr>
<p>Last revised:
<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->28 May, 2013<!--webbot bot="Timestamp" endspan i-checksum="13992" --></p>
<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->29 May, 2013<!--webbot bot="Timestamp" endspan i-checksum="13994" --></p>
<p>© Copyright Beman Dawes, 2006-2009, 2013</p>
<p>Distributed under the Boost Software License, Version 1.0. See
<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/ LICENSE_1_0.txt</a></p>

18
include/boost/endian/types.hpp
View File

@ -319,7 +319,7 @@ namespace endian
}
const char* data() const BOOST_NOEXCEPT { return m_value; }
private:
char m_value[n_bits/8];
char m_value[n_bits/8];
};
// unaligned float big endian specialization
@ -344,7 +344,7 @@ namespace endian
}
const char* data() const BOOST_NOEXCEPT { return m_value; }
private:
char m_value[sizeof(value_type)];
char m_value[sizeof(value_type)];
};
// unaligned double big endian specialization
@ -369,7 +369,7 @@ namespace endian
}
const char* data() const BOOST_NOEXCEPT { return m_value; }
private:
char m_value[sizeof(value_type)];
char m_value[sizeof(value_type)];
};
// unaligned float little endian specialization
@ -394,7 +394,7 @@ namespace endian
}
const char* data() const BOOST_NOEXCEPT { return m_value; }
private:
char m_value[sizeof(value_type)];
char m_value[sizeof(value_type)];
};
// unaligned double little endian specialization
@ -419,7 +419,7 @@ namespace endian
}
const char* data() const BOOST_NOEXCEPT { return m_value; }
private:
char m_value[sizeof(value_type)];
char m_value[sizeof(value_type)];
};
// unaligned little endian specialization
@ -453,7 +453,7 @@ namespace endian
}
const char* data() const BOOST_NOEXCEPT { return m_value; }
private:
char m_value[n_bits/8];
char m_value[n_bits/8];
};
// unaligned native endian specialization
@ -485,7 +485,7 @@ namespace endian
# endif
const char* data() const BOOST_NOEXCEPT { return m_value; }
private:
char m_value[n_bits/8];
char m_value[n_bits/8];
};
// align::yes specializations; only n_bits == 16/32/64 supported
@ -526,7 +526,7 @@ namespace endian
}
const char* data() const BOOST_NOEXCEPT {return reinterpret_cast<const char*>(&m_value);}
private:
T m_value;
T m_value;
};
// aligned little endian specialization
@ -565,7 +565,7 @@ namespace endian
}
const char* data() const BOOST_NOEXCEPT {return reinterpret_cast<const char*>(&m_value);}
private:
T m_value;
T m_value;
};
} // namespace endian

64
test/endian_test.cpp
View File

@ -559,74 +559,74 @@ namespace
void check_representation_and_range_and_ops()
{
// aligned floating point types
float big_float32_expected = std::numeric_limits<float>::max();
float big_float32_expected = (std::numeric_limits<float>::max) ();
boost::endian::big_endian(big_float32_expected);
big_float32_t big_float32(std::numeric_limits<float>::max());
big_float32_t big_float32((std::numeric_limits<float>::max) ());
VERIFY(std::memcmp(big_float32.data(),
reinterpret_cast<const char*>(&big_float32_expected), sizeof(float)) == 0);
float little_float32_expected = std::numeric_limits<float>::max();
float little_float32_expected = (std::numeric_limits<float>::max) ();
boost::endian::little_endian(little_float32_expected);
little_float32_t little_float32(std::numeric_limits<float>::max());
little_float32_t little_float32((std::numeric_limits<float>::max) ());
VERIFY(std::memcmp(little_float32.data(),
reinterpret_cast<const char*>(&little_float32_expected), sizeof(float)) == 0);
double big_float64_expected = std::numeric_limits<double>::max();
double big_float64_expected = (std::numeric_limits<double>::max) ();
boost::endian::big_endian(big_float64_expected);
big_float64_t big_float64(std::numeric_limits<double>::max());
big_float64_t big_float64((std::numeric_limits<double>::max) ());
VERIFY(std::memcmp(big_float64.data(),
reinterpret_cast<const char*>(&big_float64_expected), sizeof(double)) == 0);
double little_float64_expected = std::numeric_limits<double>::max();
double little_float64_expected = (std::numeric_limits<double>::max) ();
boost::endian::little_endian(little_float64_expected);
little_float64_t little_float64(std::numeric_limits<double>::max());
little_float64_t little_float64((std::numeric_limits<double>::max) ());
VERIFY(std::memcmp(little_float64.data(),
reinterpret_cast<const char*>(&little_float64_expected), sizeof(double)) == 0);
VERIFY_VALUE_AND_OPS( big_float32_t, float, std::numeric_limits<float>::max() );
VERIFY_VALUE_AND_OPS( big_float32_t, float, std::numeric_limits<float>::min() );
VERIFY_VALUE_AND_OPS( big_float64_t, double, std::numeric_limits<double>::max() );
VERIFY_VALUE_AND_OPS( big_float64_t, double, std::numeric_limits<double>::min() );
VERIFY_VALUE_AND_OPS( big_float32_t, float, (std::numeric_limits<float>::max) () );
VERIFY_VALUE_AND_OPS( big_float32_t, float, (std::numeric_limits<float>::min) () );
VERIFY_VALUE_AND_OPS( big_float64_t, double, (std::numeric_limits<double>::max) () );
VERIFY_VALUE_AND_OPS( big_float64_t, double, (std::numeric_limits<double>::min) () );
VERIFY_VALUE_AND_OPS( little_float32_t, float, std::numeric_limits<float>::max() );
VERIFY_VALUE_AND_OPS( little_float32_t, float, std::numeric_limits<float>::min() );
VERIFY_VALUE_AND_OPS( little_float64_t, double, std::numeric_limits<double>::max() );
VERIFY_VALUE_AND_OPS( little_float64_t, double, std::numeric_limits<double>::min() );
VERIFY_VALUE_AND_OPS( little_float32_t, float, (std::numeric_limits<float>::max) () );
VERIFY_VALUE_AND_OPS( little_float32_t, float, (std::numeric_limits<float>::min) () );
VERIFY_VALUE_AND_OPS( little_float64_t, double, (std::numeric_limits<double>::max) () );
VERIFY_VALUE_AND_OPS( little_float64_t, double, (std::numeric_limits<double>::min) () );
// unaligned floating point types
float big_float32un_expected = std::numeric_limits<float>::max();
float big_float32un_expected = (std::numeric_limits<float>::max) ();
boost::endian::big_endian(big_float32un_expected);
big_float32un_t big_float32un(std::numeric_limits<float>::max());
big_float32un_t big_float32un((std::numeric_limits<float>::max) ());
VERIFY(std::memcmp(big_float32un.data(),
reinterpret_cast<const char*>(&big_float32un_expected), sizeof(float)) == 0);
float little_float32un_expected = std::numeric_limits<float>::max();
float little_float32un_expected = (std::numeric_limits<float>::max) ();
boost::endian::little_endian(little_float32un_expected);
little_float32un_t little_float32un(std::numeric_limits<float>::max());
little_float32un_t little_float32un((std::numeric_limits<float>::max) ());
VERIFY(std::memcmp(little_float32un.data(),
reinterpret_cast<const char*>(&little_float32un_expected), sizeof(float)) == 0);
double big_float64un_expected = std::numeric_limits<double>::max();
double big_float64un_expected = (std::numeric_limits<double>::max) ();
boost::endian::big_endian(big_float64un_expected);
big_float64un_t big_float64un(std::numeric_limits<double>::max());
big_float64un_t big_float64un((std::numeric_limits<double>::max) ());
VERIFY(std::memcmp(big_float64un.data(),
reinterpret_cast<const char*>(&big_float64un_expected), sizeof(double)) == 0);
double little_float64un_expected = std::numeric_limits<double>::max();
double little_float64un_expected = (std::numeric_limits<double>::max) ();
boost::endian::little_endian(little_float64un_expected);
little_float64un_t little_float64un(std::numeric_limits<double>::max());
little_float64un_t little_float64un((std::numeric_limits<double>::max) ());
VERIFY(std::memcmp(little_float64un.data(),
reinterpret_cast<const char*>(&little_float64un_expected), sizeof(double)) == 0);
VERIFY_VALUE_AND_OPS( big_float32un_t, float, std::numeric_limits<float>::max() );
VERIFY_VALUE_AND_OPS( big_float32un_t, float, std::numeric_limits<float>::min() );
VERIFY_VALUE_AND_OPS( big_float64un_t, double, std::numeric_limits<double>::max() );
VERIFY_VALUE_AND_OPS( big_float64un_t, double, std::numeric_limits<double>::min() );
VERIFY_VALUE_AND_OPS( big_float32un_t, float, (std::numeric_limits<float>::max) () );
VERIFY_VALUE_AND_OPS( big_float32un_t, float, (std::numeric_limits<float>::min) () );
VERIFY_VALUE_AND_OPS( big_float64un_t, double, (std::numeric_limits<double>::max) () );
VERIFY_VALUE_AND_OPS( big_float64un_t, double, (std::numeric_limits<double>::min) () );
VERIFY_VALUE_AND_OPS( little_float32un_t, float, std::numeric_limits<float>::max() );
VERIFY_VALUE_AND_OPS( little_float32un_t, float, std::numeric_limits<float>::min() );
VERIFY_VALUE_AND_OPS( little_float64un_t, double, std::numeric_limits<double>::max() );
VERIFY_VALUE_AND_OPS( little_float64un_t, double, std::numeric_limits<double>::min() );
VERIFY_VALUE_AND_OPS( little_float32un_t, float, (std::numeric_limits<float>::max) () );
VERIFY_VALUE_AND_OPS( little_float32un_t, float, (std::numeric_limits<float>::min) () );
VERIFY_VALUE_AND_OPS( little_float64un_t, double, (std::numeric_limits<double>::max) () );
VERIFY_VALUE_AND_OPS( little_float64un_t, double, (std::numeric_limits<double>::min) () );
float a = 1.0F;
big_float32_t b(1.0F);

9
test/intrinsic_test.cpp
View File

@ -5,8 +5,7 @@
#include "test.hpp"
#include <iostream>
#include <cassert>
//#include <cstdint>
#include <boost/assert.hpp>
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
@ -18,11 +17,11 @@ int main()
#ifndef BOOST_ENDIAN_NO_INTRINSICS
uint16_t x2 = 0x1122U;
assert(BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_2(x2) == 0x2211U);
BOOST_ASSERT(BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_2(x2) == 0x2211U);
uint32_t x4 = 0x11223344UL;
assert(BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_4(x4) == 0x44332211UL);
BOOST_ASSERT(BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_4(x4) == 0x44332211UL);
uint64_t x8 = 0x1122334455667788U;
assert(BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_8(x8) == 0x8877665544332211ULL);
BOOST_ASSERT(BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_8(x8) == 0x8877665544332211ULL);
#endif
return 0;
}