Integer encoding utilities.

This adds function for reading little-endian i32, u32, i64, and u64 from
pointers to memory. This allows us to decode integers in a single line
instead of doing a declare+memcpy+byteswap that clutters the code and
prevents us from using `const` and correct signedness. Instead, we can
declare and initialize integers of the exact size and sign that we want
in a single line.

Author: vector-of-bool

src/common/src/mlib/intencode.h

@@ -0,0 +1,161 @@
+/**
+ * @file mlib/intencode.h
+ * @brief Integer encoding functions
+ * @date 2025-01-31
+ *
+ * @copyright Copyright (c) 2025
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <mlib/config.h>
+#include <mlib/loop.h>
+
+#include <stdint.h>
+#include <string.h>
+
+/**
+ * @brief Decode an unsigned 32-bit little-endian integer from a memory buffer
+ */
+static inline uint32_t
+mlib_read_u32le (const void *buf)
+{
+   uint32_t ret = 0;
+   if (mlib_is_little_endian ()) {
+      // Optimize: The platform uses a LE encoding already
+      memcpy (&ret, buf, sizeof ret);
+   } else {
+      // Portable decode of an LE integer
+      const uint8_t *cptr = (const uint8_t *) buf;
+      mlib_foreach_urange (i, sizeof ret) {
+         ret <<= 8;
+         ret |= cptr[i];
+      }
+   }
+   return ret;
+}
+
+/**
+ * @brief Decode an signed 32-bit little-endian integer from a memory buffer
+ */
+static inline int32_t
+mlib_read_i32le (const void *buf)
+{
+   return (int32_t) mlib_read_u32le (buf);
+}
+
+/**
+ * @brief Decode an unsigned 64-bit little-endian integer from a memory buffer
+ */
+static inline uint64_t
+mlib_read_u64le (const void *buf)
+{
+   uint64_t ret = 0;
+   if (mlib_is_little_endian ()) {
+      // Optimize: The platform uses a LE encoding already
+      memcpy (&ret, buf, sizeof ret);
+   } else {
+      // Portable decode of an LE integer
+      const uint8_t *cptr = (const uint8_t *) buf;
+      mlib_foreach_urange (i, sizeof ret) {
+         ret <<= 8;
+         ret |= cptr[i];
+      }
+   }
+   return ret;
+}
+
+/**
+ * @brief Decode an signed 64-bit little-endian integer from a memory buffer
+ */
+static inline int64_t
+mlib_read_i64le (const void *buf)
+{
+   return (int64_t) mlib_read_u64le (buf);
+}
+
+/**
+ * @brief Write an unsigned 32-bit little-endian integer into a destination
+ *
+ * @return void* The address after the written value
+ */
+static inline void *
+mlib_write_u32le (void *out, const uint32_t value)
+{
+   uint8_t *o = (uint8_t *) out;
+   if (mlib_is_little_endian ()) {
+      memcpy (o, &value, sizeof value);
+      return o + sizeof value;
+   }
+   mlib_foreach_urange (i, sizeof value) {
+      *o++ = (value >> (8u * i)) & 0xffu;
+   }
+   return o;
+}
+
+/**
+ * @brief Write a signed 32-bit little-endian integer into a destination
+ *
+ * @return void* The address after the written value
+ */
+static inline void *
+mlib_write_i32le (void *out, int32_t value)
+{
+   return mlib_write_u32le (out, (uint32_t) value);
+}
+
+/**
+ * @brief Write an unsigned 64-bit little-endian integer into a destination
+ *
+ * @return void* The address after the written value
+ */
+static inline void *
+mlib_write_u64le (void *out, const uint64_t value)
+{
+   uint8_t *o = (uint8_t *) out;
+   if (mlib_is_little_endian ()) {
+      memcpy (o, &value, sizeof value);
+      return o + sizeof value;
+   }
+   mlib_foreach_urange (i, sizeof value) {
+      *o++ = (value >> (8u * i)) & 0xffu;
+   }
+   return o;
+}
+
+/**
+ * @brief Write an signed 64-bit little-endian integer into a destination
+ *
+ * @return void* The address after the written value
+ */
+static inline void *
+mlib_write_i64le (void *out, int64_t value)
+{
+   return mlib_write_u64le (out, (uint64_t) value);
+}
+
+/**
+ * @brief Write a little-endian 64-bit floating point (double) to the given
+ * memory location
+ *
+ * @return void* The address after the written value.
+ */
+static inline void *
+mlib_write_f64le (void *out, double d)
+{
+   mlib_static_assert (sizeof (double) == sizeof (uint64_t));
+   uint64_t bits;
+   memcpy (&bits, &d, sizeof d);
+   return mlib_write_u64le (out, bits);
+}

src/common/tests/test-mlib.c

@@ -2,6 +2,7 @@
 
 #include <mlib/intutil.h>
 #include <mlib/config.h>
+#include <mlib/intencode.h>
 #include <mlib/loop.h>
 #include <mlib/cmp.h>
 #include <mlib/test.h>
@@ -401,6 +402,31 @@ _test_assert_aborts (void)
    ASSERT (a == 0);
 }
 
+void
+_test_int_encoding (void)
+{
+   {
+      const char *buf = "\x01\x02\x03\x04";
+      const uint32_t val = mlib_read_u32le (buf);
+      mlib_check (val, eq, 0x04030201);
+   }
+
+   {
+      char buf[9] = {0};
+      char *o = mlib_write_i32le (buf, 0x01020304);
+      mlib_check (o, ptreq, buf + 4);
+      mlib_check (buf, streq, "\x04\x03\x02\x01");
+
+      o = mlib_write_i32le (o, 42);
+      mlib_check (o, ptreq, buf + 8);
+      mlib_check (buf, streq, "\x04\x03\x02\x01*");
+
+      o = mlib_write_i64le (buf, 0x0102030405060708);
+      mlib_check (o, ptreq, buf + 8);
+      mlib_check (buf, streq, "\x08\x07\x06\x05\x04\x03\x02\x01");
+   }
+}
+
 void
 _test_foreach (void)
 {
@@ -446,7 +472,8 @@ _test_foreach (void)
    int arr[] = {1, 2, 3};
    int sum = 0;
    n_loops = 0;
-   mlib_foreach_arr (int, n, arr) {
+   mlib_foreach_arr (int, n, arr)
+   {
       n_loops++;
       sum += *n;
    }
@@ -463,6 +490,7 @@ test_mlib_install (TestSuite *suite)
    TestSuite_Add (suite, "/mlib/cmp", _test_cmp);
    TestSuite_Add (suite, "/mlib/in-range", _test_in_range);
    TestSuite_Add (suite, "/mlib/assert-aborts", _test_assert_aborts);
+   TestSuite_Add (suite, "/mlib/int-encoding", _test_int_encoding);
    TestSuite_Add (suite, "/mlib/foreach", _test_foreach);
 }