use portable endian swapping

me · me · commit 37fd976c3469 · 2025-11-04T10:50:21.000Z
diff --git a/src/msgpack.h b/src/msgpack.h
@@ -2,7 +2,6 @@
 
 #include <cstdint>
 #include <cstring>
-#include <endian.h>
 #include <type_traits>
 #include <limits>
 #include <utility>
@@ -467,23 +466,23 @@ namespace msgpackcpp
         {
             // unsigned 16
             constexpr uint8_t format = MSGPACK_U16;
-            const     uint16_t v16   = htobe16(static_cast<uint16_t>(v));
+            const     uint16_t v16   = host_to_b16(static_cast<uint16_t>(v));
             out((const char*)&format, 1);
             out((const char*)&v16, 2);
         }    
         else if (v <= std::numeric_limits<uint32_t>::max())
         {
             // unsigned 32
             constexpr uint8_t format = 0xce;
-            const     uint32_t v32   = htobe32(static_cast<uint32_t>(v));
+            const     uint32_t v32   = host_to_b32(static_cast<uint32_t>(v));
             out((const char*)&format, 1);
             out((const char*)&v32, 4);
         }
         else
         {
             // unsigned 64
             constexpr uint8_t format = 0xcf;
-            const     uint64_t v64   = htobe64(static_cast<uint64_t>(v));
+            const     uint64_t v64   = host_to_b64(static_cast<uint64_t>(v));
             out((const char*)&format, 1);
             out((const char*)&v64, 8);
         }
@@ -516,23 +515,23 @@ namespace msgpackcpp
         {
             // negative - int16
             constexpr uint8_t format = 0xd1;
-            const     uint16_t v16   = htobe16(bit_cast<uint16_t>(static_cast<int16_t>(v)));
+            const     uint16_t v16   = host_to_b16(bit_cast<uint16_t>(static_cast<int16_t>(v)));
             out((const char*)&format, 1);
             out((const char*)&v16, 2);
         }    
         else if (v >= std::numeric_limits<int32_t>::min())
         {
             // negative - int32_t
             constexpr uint8_t format = 0xd2;
-            const     uint32_t v32   = htobe32(bit_cast<uint32_t>(static_cast<int32_t>(v)));
+            const     uint32_t v32   = host_to_b32(bit_cast<uint32_t>(static_cast<int32_t>(v)));
             out((const char*)&format, 1);
             out((const char*)&v32, 4);
         }
         else
         {
             // negative - int64_T
             constexpr uint8_t format = 0xd3;
-            const     uint64_t v64   = htobe64(bit_cast<uint64_t>(static_cast<int64_t>(v)));
+            const     uint64_t v64   = host_to_b64(bit_cast<uint64_t>(static_cast<int64_t>(v)));
             out((const char*)&format, 1);
             out((const char*)&v64, 8);
         }
@@ -566,21 +565,21 @@ namespace msgpackcpp
             // unsigned 16
             uint16_t tmp{};
             in((char*)&tmp, 2);
-            v = htobe16(tmp);
+            v = host_to_b16(tmp);
         }
         else if (format == 0xce)
         {
             // unsigned 32
             uint32_t tmp{};
             in((char*)&tmp, 4);
-            v = htobe32(tmp);
+            v = host_to_b32(tmp);
         }
         else if (format == 0xcf)
         {
             // unsigned 64
             uint64_t tmp{};
             in((char*)&tmp, 8);
-            v = htobe64(tmp);
+            v = host_to_b64(tmp);
         }
         else if (format == 0xd0)
         {
@@ -594,21 +593,21 @@ namespace msgpackcpp
             // signed 16
             uint16_t tmp{};
             in((char*)&tmp, 2);
-            v = bit_cast<int16_t>(htobe16(tmp));
+            v = bit_cast<int16_t>(host_to_b16(tmp));
         }
         else if (format == 0xd2)
         {
             // signed 32
             uint32_t tmp{};
             in((char*)&tmp, 4);
-            v = bit_cast<int32_t>(htobe32(tmp));
+            v = bit_cast<int32_t>(host_to_b32(tmp));
         }
         else if (format == 0xd3)
         {
             // signed 64
             uint64_t tmp{};
             in((char*)&tmp, 8);
-            v = bit_cast<int64_t>(htobe64(tmp));
+            v = bit_cast<int64_t>(host_to_b64(tmp));
         }
         else
             throw std::system_error(BAD_FORMAT);
@@ -620,7 +619,7 @@ namespace msgpackcpp
     inline void serialize(Stream& out, float v)
     {
         constexpr uint8_t  format   = 0xca;
-        const     uint32_t tmp      = htobe32(bit_cast<uint32_t>(v)); 
+        const     uint32_t tmp      = host_to_b32(bit_cast<uint32_t>(v)); 
         out((const char*)&format, 1);
         out((const char*)&tmp, 4);
     }
@@ -629,7 +628,7 @@ namespace msgpackcpp
     inline void serialize(Stream& out, double v)
     {
         constexpr uint8_t  format   = 0xcb;
-        const     uint64_t tmp      = htobe64(bit_cast<uint64_t>(v)); 
+        const     uint64_t tmp      = host_to_b64(bit_cast<uint64_t>(v)); 
         out((const char*)&format, 1);
         out((const char*)&tmp, 8);
     }
@@ -644,13 +643,13 @@ namespace msgpackcpp
         {
             uint32_t tmp{};
             in((char*)&tmp, 4);
-            v = bit_cast<float>(htobe32(tmp));
+            v = bit_cast<float>(host_to_b32(tmp));
         }
         else if (format == 0xcb)
         {
             uint64_t tmp{};
             in((char*)&tmp, 8);
-            v = bit_cast<double>(htobe64(tmp));
+            v = bit_cast<double>(host_to_b64(tmp));
         }
         else
             throw std::system_error(BAD_FORMAT);
@@ -676,14 +675,14 @@ namespace msgpackcpp
         else if (size < 65536)
         {
             constexpr uint8_t  format = 0xda;
-            const     uint16_t size16 = htobe16(static_cast<uint16_t>(size));
+            const     uint16_t size16 = host_to_b16(static_cast<uint16_t>(size));
             out((const char*)&format, 1);
             out((const char*)&size16, 2);
         }
         else 
         {
             constexpr uint8_t  format = 0xdb;
-            const     uint32_t size32 = htobe32(static_cast<uint32_t>(size));
+            const     uint32_t size32 = host_to_b32(static_cast<uint32_t>(size));
             out((const char*)&format, 1);
             out((const char*)&size32, 4);
         }
@@ -709,13 +708,13 @@ namespace msgpackcpp
         {
             uint16_t size16{};
             in((char*)&size16, 2);
-            size = htobe16(size16);
+            size = host_to_b16(size16);
         }
         else if (format == 0xdb)
         {
             uint32_t size32{};
             in((char*)&size32, 4);
-            size = htobe32(size32);
+            size = host_to_b32(size32);
         }
         else
             throw std::system_error(BAD_FORMAT);
@@ -758,14 +757,14 @@ namespace msgpackcpp
         else if (len < 65536)
         {
             constexpr uint8_t  format = 0xc5;
-            const     uint16_t size16 = htobe16(static_cast<uint16_t>(len));
+            const     uint16_t size16 = host_to_b16(static_cast<uint16_t>(len));
             out((const char*)&format, 1);
             out((const char*)&size16, 2);
         }
         else 
         {
             constexpr uint8_t  format = 0xc6;
-            const     uint32_t size32 = htobe32(static_cast<uint32_t>(len));
+            const     uint32_t size32 = host_to_b32(static_cast<uint32_t>(len));
             out((const char*)&format, 1);
             out((const char*)&size32, 4);
         }
@@ -787,13 +786,13 @@ namespace msgpackcpp
         {
             uint16_t size16{};
             in((char*)&size16, 2);
-            size = htobe16(size16);
+            size = host_to_b16(size16);
         }
         else if (format == 0xc6)
         {
             uint32_t size32{};
             in((char*)&size32, 4);
-            size = htobe32(size32);
+            size = host_to_b32(size32);
         }
         else
             throw std::system_error(BAD_FORMAT);
@@ -849,14 +848,14 @@ namespace msgpackcpp
         else if (size < 65536)
         {
             constexpr uint8_t  format = 0xdc;
-            const     uint16_t size16 = htobe16(static_cast<uint16_t>(size));
+            const     uint16_t size16 = host_to_b16(static_cast<uint16_t>(size));
             out((const char*)&format, 1);
             out((const char*)&size16, 2);
         }
         else 
         {
             constexpr uint8_t  format = 0xdd;
-            const     uint32_t size32 = htobe32(static_cast<uint32_t>(size));
+            const     uint32_t size32 = host_to_b32(static_cast<uint32_t>(size));
             out((const char*)&format, 1);
             out((const char*)&size32, 4);
         }
@@ -876,13 +875,13 @@ namespace msgpackcpp
         {
             uint16_t size16{};
             in((char*)&size16, 2);
-            size = htobe16(size16);
+            size = host_to_b16(size16);
         }
         else if (format == 0xdd)
         {
             uint32_t size32{};
             in((char*)&size32, 4);
-            size = htobe32(size32);
+            size = host_to_b32(size32);
         }
         else
             throw std::system_error(BAD_FORMAT);
@@ -919,14 +918,14 @@ namespace msgpackcpp
         else if (size < 65536)
         {
             constexpr uint8_t  format = 0xde;
-            const     uint16_t size16 = htobe16(static_cast<uint16_t>(size));
+            const     uint16_t size16 = host_to_b16(static_cast<uint16_t>(size));
             out((const char*)&format, 1);
             out((const char*)&size16, 2);
         }
         else 
         {
             constexpr uint8_t  format = 0xdf;
-            const     uint32_t size32 = htobe32(static_cast<uint32_t>(size));
+            const     uint32_t size32 = host_to_b32(static_cast<uint32_t>(size));
             out((const char*)&format, 1);
             out((const char*)&size32, 4);
         }
@@ -946,13 +945,13 @@ namespace msgpackcpp
         {
             uint16_t size16{};
             in((char*)&size16, 2);
-            size = htobe16(size16);
+            size = host_to_b16(size16);
         }
         else if (format == 0xdf)
         {
             uint32_t size32{};
             in((char*)&size32, 4);
-            size = htobe32(size32);
+            size = host_to_b32(size32);
         }
         else
             throw std::system_error(BAD_FORMAT);

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@`
`2`	`2`
`3`	`3`	`#include <cstdint>`
`4`	`4`	`#include <cstring>`
`5`		`-#include <endian.h>`
`6`	`5`	`#include <type_traits>`
`7`	`6`	`#include <limits>`
`8`	`7`	`#include <utility>`
`@@ -467,23 +466,23 @@ namespace msgpackcpp`
`467`	`466`	`{`
`468`	`467`	`// unsigned 16`
`469`	`468`	`constexpr uint8_t format = MSGPACK_U16;`
`470`		`- const uint16_t v16 = htobe16(static_cast<uint16_t>(v));`
	`469`	`+ const uint16_t v16 = host_to_b16(static_cast<uint16_t>(v));`
`471`	`470`	`out((const char*)&format, 1);`
`472`	`471`	`out((const char*)&v16, 2);`
`473`	`472`	`}`
`474`	`473`	`else if (v <= std::numeric_limits<uint32_t>::max())`
`475`	`474`	`{`
`476`	`475`	`// unsigned 32`
`477`	`476`	`constexpr uint8_t format = 0xce;`
`478`		`- const uint32_t v32 = htobe32(static_cast<uint32_t>(v));`
	`477`	`+ const uint32_t v32 = host_to_b32(static_cast<uint32_t>(v));`
`479`	`478`	`out((const char*)&format, 1);`
`480`	`479`	`out((const char*)&v32, 4);`
`481`	`480`	`}`
`482`	`481`	`else`
`483`	`482`	`{`
`484`	`483`	`// unsigned 64`
`485`	`484`	`constexpr uint8_t format = 0xcf;`
`486`		`- const uint64_t v64 = htobe64(static_cast<uint64_t>(v));`
	`485`	`+ const uint64_t v64 = host_to_b64(static_cast<uint64_t>(v));`
`487`	`486`	`out((const char*)&format, 1);`
`488`	`487`	`out((const char*)&v64, 8);`
`489`	`488`	`}`
`@@ -516,23 +515,23 @@ namespace msgpackcpp`
`516`	`515`	`{`
`517`	`516`	`// negative - int16`
`518`	`517`	`constexpr uint8_t format = 0xd1;`
`519`		`- const uint16_t v16 = htobe16(bit_cast<uint16_t>(static_cast<int16_t>(v)));`
	`518`	`+ const uint16_t v16 = host_to_b16(bit_cast<uint16_t>(static_cast<int16_t>(v)));`
`520`	`519`	`out((const char*)&format, 1);`
`521`	`520`	`out((const char*)&v16, 2);`
`522`	`521`	`}`
`523`	`522`	`else if (v >= std::numeric_limits<int32_t>::min())`
`524`	`523`	`{`
`525`	`524`	`// negative - int32_t`
`526`	`525`	`constexpr uint8_t format = 0xd2;`
`527`		`- const uint32_t v32 = htobe32(bit_cast<uint32_t>(static_cast<int32_t>(v)));`
	`526`	`+ const uint32_t v32 = host_to_b32(bit_cast<uint32_t>(static_cast<int32_t>(v)));`
`528`	`527`	`out((const char*)&format, 1);`
`529`	`528`	`out((const char*)&v32, 4);`
`530`	`529`	`}`
`531`	`530`	`else`
`532`	`531`	`{`
`533`	`532`	`// negative - int64_T`
`534`	`533`	`constexpr uint8_t format = 0xd3;`
`535`		`- const uint64_t v64 = htobe64(bit_cast<uint64_t>(static_cast<int64_t>(v)));`
	`534`	`+ const uint64_t v64 = host_to_b64(bit_cast<uint64_t>(static_cast<int64_t>(v)));`
`536`	`535`	`out((const char*)&format, 1);`
`537`	`536`	`out((const char*)&v64, 8);`
`538`	`537`	`}`
`@@ -566,21 +565,21 @@ namespace msgpackcpp`
`566`	`565`	`// unsigned 16`
`567`	`566`	`uint16_t tmp{};`
`568`	`567`	`in((char*)&tmp, 2);`
`569`		`- v = htobe16(tmp);`
	`568`	`+ v = host_to_b16(tmp);`
`570`	`569`	`}`
`571`	`570`	`else if (format == 0xce)`
`572`	`571`	`{`
`573`	`572`	`// unsigned 32`
`574`	`573`	`uint32_t tmp{};`
`575`	`574`	`in((char*)&tmp, 4);`
`576`		`- v = htobe32(tmp);`
	`575`	`+ v = host_to_b32(tmp);`
`577`	`576`	`}`
`578`	`577`	`else if (format == 0xcf)`
`579`	`578`	`{`
`580`	`579`	`// unsigned 64`
`581`	`580`	`uint64_t tmp{};`
`582`	`581`	`in((char*)&tmp, 8);`
`583`		`- v = htobe64(tmp);`
	`582`	`+ v = host_to_b64(tmp);`
`584`	`583`	`}`
`585`	`584`	`else if (format == 0xd0)`
`586`	`585`	`{`
`@@ -594,21 +593,21 @@ namespace msgpackcpp`
`594`	`593`	`// signed 16`
`595`	`594`	`uint16_t tmp{};`
`596`	`595`	`in((char*)&tmp, 2);`
`597`		`- v = bit_cast<int16_t>(htobe16(tmp));`
	`596`	`+ v = bit_cast<int16_t>(host_to_b16(tmp));`
`598`	`597`	`}`
`599`	`598`	`else if (format == 0xd2)`
`600`	`599`	`{`
`601`	`600`	`// signed 32`
`602`	`601`	`uint32_t tmp{};`
`603`	`602`	`in((char*)&tmp, 4);`
`604`		`- v = bit_cast<int32_t>(htobe32(tmp));`
	`603`	`+ v = bit_cast<int32_t>(host_to_b32(tmp));`
`605`	`604`	`}`
`606`	`605`	`else if (format == 0xd3)`
`607`	`606`	`{`
`608`	`607`	`// signed 64`
`609`	`608`	`uint64_t tmp{};`
`610`	`609`	`in((char*)&tmp, 8);`
`611`		`- v = bit_cast<int64_t>(htobe64(tmp));`
	`610`	`+ v = bit_cast<int64_t>(host_to_b64(tmp));`
`612`	`611`	`}`
`613`	`612`	`else`
`614`	`613`	`throw std::system_error(BAD_FORMAT);`
`@@ -620,7 +619,7 @@ namespace msgpackcpp`
`620`	`619`	`inline void serialize(Stream& out, float v)`
`621`	`620`	`{`
`622`	`621`	`constexpr uint8_t format = 0xca;`
`623`		`- const uint32_t tmp = htobe32(bit_cast<uint32_t>(v));`
	`622`	`+ const uint32_t tmp = host_to_b32(bit_cast<uint32_t>(v));`
`624`	`623`	`out((const char*)&format, 1);`
`625`	`624`	`out((const char*)&tmp, 4);`
`626`	`625`	`}`
`@@ -629,7 +628,7 @@ namespace msgpackcpp`
`629`	`628`	`inline void serialize(Stream& out, double v)`
`630`	`629`	`{`
`631`	`630`	`constexpr uint8_t format = 0xcb;`
`632`		`- const uint64_t tmp = htobe64(bit_cast<uint64_t>(v));`
	`631`	`+ const uint64_t tmp = host_to_b64(bit_cast<uint64_t>(v));`
`633`	`632`	`out((const char*)&format, 1);`
`634`	`633`	`out((const char*)&tmp, 8);`
`635`	`634`	`}`
`@@ -644,13 +643,13 @@ namespace msgpackcpp`
`644`	`643`	`{`
`645`	`644`	`uint32_t tmp{};`
`646`	`645`	`in((char*)&tmp, 4);`
`647`		`- v = bit_cast<float>(htobe32(tmp));`
	`646`	`+ v = bit_cast<float>(host_to_b32(tmp));`
`648`	`647`	`}`
`649`	`648`	`else if (format == 0xcb)`
`650`	`649`	`{`
`651`	`650`	`uint64_t tmp{};`
`652`	`651`	`in((char*)&tmp, 8);`
`653`		`- v = bit_cast<double>(htobe64(tmp));`
	`652`	`+ v = bit_cast<double>(host_to_b64(tmp));`
`654`	`653`	`}`
`655`	`654`	`else`
`656`	`655`	`throw std::system_error(BAD_FORMAT);`
`@@ -676,14 +675,14 @@ namespace msgpackcpp`
`676`	`675`	`else if (size < 65536)`
`677`	`676`	`{`
`678`	`677`	`constexpr uint8_t format = 0xda;`
`679`		`- const uint16_t size16 = htobe16(static_cast<uint16_t>(size));`
	`678`	`+ const uint16_t size16 = host_to_b16(static_cast<uint16_t>(size));`
`680`	`679`	`out((const char*)&format, 1);`
`681`	`680`	`out((const char*)&size16, 2);`
`682`	`681`	`}`
`683`	`682`	`else`
`684`	`683`	`{`
`685`	`684`	`constexpr uint8_t format = 0xdb;`
`686`		`- const uint32_t size32 = htobe32(static_cast<uint32_t>(size));`
	`685`	`+ const uint32_t size32 = host_to_b32(static_cast<uint32_t>(size));`
`687`	`686`	`out((const char*)&format, 1);`
`688`	`687`	`out((const char*)&size32, 4);`
`689`	`688`	`}`
`@@ -709,13 +708,13 @@ namespace msgpackcpp`
`709`	`708`	`{`
`710`	`709`	`uint16_t size16{};`
`711`	`710`	`in((char*)&size16, 2);`
`712`		`- size = htobe16(size16);`
	`711`	`+ size = host_to_b16(size16);`
`713`	`712`	`}`
`714`	`713`	`else if (format == 0xdb)`
`715`	`714`	`{`
`716`	`715`	`uint32_t size32{};`
`717`	`716`	`in((char*)&size32, 4);`
`718`		`- size = htobe32(size32);`
	`717`	`+ size = host_to_b32(size32);`
`719`	`718`	`}`
`720`	`719`	`else`
`721`	`720`	`throw std::system_error(BAD_FORMAT);`
`@@ -758,14 +757,14 @@ namespace msgpackcpp`
`758`	`757`	`else if (len < 65536)`
`759`	`758`	`{`
`760`	`759`	`constexpr uint8_t format = 0xc5;`
`761`		`- const uint16_t size16 = htobe16(static_cast<uint16_t>(len));`
	`760`	`+ const uint16_t size16 = host_to_b16(static_cast<uint16_t>(len));`
`762`	`761`	`out((const char*)&format, 1);`
`763`	`762`	`out((const char*)&size16, 2);`
`764`	`763`	`}`
`765`	`764`	`else`
`766`	`765`	`{`
`767`	`766`	`constexpr uint8_t format = 0xc6;`
`768`		`- const uint32_t size32 = htobe32(static_cast<uint32_t>(len));`
	`767`	`+ const uint32_t size32 = host_to_b32(static_cast<uint32_t>(len));`
`769`	`768`	`out((const char*)&format, 1);`
`770`	`769`	`out((const char*)&size32, 4);`
`771`	`770`	`}`
`@@ -787,13 +786,13 @@ namespace msgpackcpp`
`787`	`786`	`{`
`788`	`787`	`uint16_t size16{};`
`789`	`788`	`in((char*)&size16, 2);`
`790`		`- size = htobe16(size16);`
	`789`	`+ size = host_to_b16(size16);`
`791`	`790`	`}`
`792`	`791`	`else if (format == 0xc6)`
`793`	`792`	`{`
`794`	`793`	`uint32_t size32{};`
`795`	`794`	`in((char*)&size32, 4);`
`796`		`- size = htobe32(size32);`
	`795`	`+ size = host_to_b32(size32);`
`797`	`796`	`}`
`798`	`797`	`else`
`799`	`798`	`throw std::system_error(BAD_FORMAT);`
`@@ -849,14 +848,14 @@ namespace msgpackcpp`
`849`	`848`	`else if (size < 65536)`
`850`	`849`	`{`
`851`	`850`	`constexpr uint8_t format = 0xdc;`
`852`		`- const uint16_t size16 = htobe16(static_cast<uint16_t>(size));`
	`851`	`+ const uint16_t size16 = host_to_b16(static_cast<uint16_t>(size));`
`853`	`852`	`out((const char*)&format, 1);`
`854`	`853`	`out((const char*)&size16, 2);`
`855`	`854`	`}`
`856`	`855`	`else`
`857`	`856`	`{`
`858`	`857`	`constexpr uint8_t format = 0xdd;`
`859`		`- const uint32_t size32 = htobe32(static_cast<uint32_t>(size));`
	`858`	`+ const uint32_t size32 = host_to_b32(static_cast<uint32_t>(size));`
`860`	`859`	`out((const char*)&format, 1);`
`861`	`860`	`out((const char*)&size32, 4);`
`862`	`861`	`}`
`@@ -876,13 +875,13 @@ namespace msgpackcpp`
`876`	`875`	`{`
`877`	`876`	`uint16_t size16{};`
`878`	`877`	`in((char*)&size16, 2);`
`879`		`- size = htobe16(size16);`
	`878`	`+ size = host_to_b16(size16);`
`880`	`879`	`}`
`881`	`880`	`else if (format == 0xdd)`
`882`	`881`	`{`
`883`	`882`	`uint32_t size32{};`
`884`	`883`	`in((char*)&size32, 4);`
`885`		`- size = htobe32(size32);`
	`884`	`+ size = host_to_b32(size32);`
`886`	`885`	`}`
`887`	`886`	`else`
`888`	`887`	`throw std::system_error(BAD_FORMAT);`
`@@ -919,14 +918,14 @@ namespace msgpackcpp`
`919`	`918`	`else if (size < 65536)`
`920`	`919`	`{`
`921`	`920`	`constexpr uint8_t format = 0xde;`
`922`		`- const uint16_t size16 = htobe16(static_cast<uint16_t>(size));`
	`921`	`+ const uint16_t size16 = host_to_b16(static_cast<uint16_t>(size));`
`923`	`922`	`out((const char*)&format, 1);`
`924`	`923`	`out((const char*)&size16, 2);`
`925`	`924`	`}`
`926`	`925`	`else`
`927`	`926`	`{`
`928`	`927`	`constexpr uint8_t format = 0xdf;`
`929`		`- const uint32_t size32 = htobe32(static_cast<uint32_t>(size));`
	`928`	`+ const uint32_t size32 = host_to_b32(static_cast<uint32_t>(size));`
`930`	`929`	`out((const char*)&format, 1);`
`931`	`930`	`out((const char*)&size32, 4);`
`932`	`931`	`}`
`@@ -946,13 +945,13 @@ namespace msgpackcpp`
`946`	`945`	`{`
`947`	`946`	`uint16_t size16{};`
`948`	`947`	`in((char*)&size16, 2);`
`949`		`- size = htobe16(size16);`
	`948`	`+ size = host_to_b16(size16);`
`950`	`949`	`}`
`951`	`950`	`else if (format == 0xdf)`
`952`	`951`	`{`
`953`	`952`	`uint32_t size32{};`
`954`	`953`	`in((char*)&size32, 4);`
`955`		`- size = htobe32(size32);`
	`954`	`+ size = host_to_b32(size32);`
`956`	`955`	`}`
`957`	`956`	`else`
`958`	`957`	`throw std::system_error(BAD_FORMAT);`