Indent

hydrogen.h

@@ -2,28 +2,26 @@
 #define hydrogen_H
 
 #if !(defined(__linux__) && defined(__KERNEL__))
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
+#    include <stdbool.h>
+#    include <stdint.h>
+#    include <stdlib.h>
 #endif
 
-#ifndef __cplusplus
-#ifdef __GNUC__
-#pragma GCC diagnostic ignored "-Wdeclaration-after-statement"
-#endif
+#if !defined(__cplusplus) && defined(__GNUC__)
+#    pragma GCC diagnostic ignored "-Wdeclaration-after-statement"
 #endif
 
 #ifdef __cplusplus
-#ifdef __GNUC__
-#pragma GCC diagnostic ignored "-Wlong-long"
-#endif
+#    ifdef __GNUC__
+#        pragma GCC diagnostic ignored "-Wlong-long"
+#    endif
 extern "C" {
 #endif
 
 #if defined(__clang__) || defined(__GNUC__)
-#define _hydro_attr_(X) __attribute__(X)
+#    define _hydro_attr_(X) __attribute__(X)
 #else
-#define _hydro_attr_(X)
+#    define _hydro_attr_(X)
 #endif
 #define _hydro_attr_deprecated_         _hydro_attr_((deprecated))
 #define _hydro_attr_malloc_             _hydro_attr_((malloc))
@@ -33,11 +31,11 @@ extern "C" {
 #define _hydro_attr_weak_               _hydro_attr_((weak))
 
 #if defined(__INTEL_COMPILER) || defined(_MSC_VER)
-#define _hydro_attr_aligned_(X) __declspec(align(X))
+#    define _hydro_attr_aligned_(X) __declspec(align(X))
 #elif defined(__clang__) || defined(__GNUC__)
-#define _hydro_attr_aligned_(X) _hydro_attr_((aligned(X)))
+#    define _hydro_attr_aligned_(X) _hydro_attr_((aligned(X)))
 #else
-#define _hydro_attr_aligned_(X)
+#    define _hydro_attr_aligned_(X)
 #endif
 
 #define HYDRO_VERSION_MAJOR 1
@@ -327,9 +325,9 @@ int hydro_unpad(const unsigned char *buf, size_t padded_buflen, size_t blocksize
 #define HYDRO_HWTYPE_ATMEGA328 1
 
 #ifndef HYDRO_HWTYPE
-#ifdef __AVR__
-#define HYDRO_HWTYPE HYDRO_HWTYPE_ATMEGA328
-#endif
+#    ifdef __AVR__
+#        define HYDRO_HWTYPE HYDRO_HWTYPE_ATMEGA328
+#    endif
 #endif
 
 #ifdef __cplusplus

impl/common.h

@@ -1,56 +1,56 @@
 #if defined(__linux__) && defined(__KERNEL__)
-#define TLS /* Danger: at most one call into hydro_*() at a time */
-#define CHAR_BIT 8
-#define abort BUG
-#define uint_fast16_t uint16_t
-#define errno hydro_errno
+#    define TLS           /* Danger: at most one call into hydro_*() at a time */
+#    define CHAR_BIT      8
+#    define abort         BUG
+#    define uint_fast16_t uint16_t
+#    define errno         hydro_errno
 static int errno;
 #else
-#include <errno.h>
-#include <limits.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
+#    include <errno.h>
+#    include <limits.h>
+#    include <stdbool.h>
+#    include <stdint.h>
+#    include <stdlib.h>
+#    include <string.h>
 #endif
 
 #if !defined(__unix__) && (defined(__APPLE__) || defined(__linux__))
-#define __unix__ 1
+#    define __unix__ 1
 #endif
 #ifndef __GNUC__
-#define __restrict__
+#    define __restrict__
 #endif
 
 #if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
     __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#define NATIVE_BIG_ENDIAN
+#    define NATIVE_BIG_ENDIAN
 #endif
 #ifndef NATIVE_BIG_ENDIAN
-#ifndef NATIVE_LITTLE_ENDIAN
-#define NATIVE_LITTLE_ENDIAN
-#endif
+#    ifndef NATIVE_LITTLE_ENDIAN
+#        define NATIVE_LITTLE_ENDIAN
+#    endif
 #endif
 
 #ifndef TLS
-#if defined(_WIN32) && !defined(__GNUC__)
-#define TLS __declspec(thread)
-#elif (defined(__clang__) || defined(__GNUC__)) && defined(__unix__) && !defined(__TINYC__)
-#define TLS __thread
-#else
-#define TLS
-#endif
+#    if defined(_WIN32) && !defined(__GNUC__)
+#        define TLS __declspec(thread)
+#    elif (defined(__clang__) || defined(__GNUC__)) && defined(__unix__) && !defined(__TINYC__)
+#        define TLS __thread
+#    else
+#        define TLS
+#    endif
 #endif
 
 #ifndef SIZE_MAX
-#define SIZE_MAX ((size_t) -1)
+#    define SIZE_MAX ((size_t) -1)
 #endif
 
 #ifdef __OpenBSD__
-#define HAVE_EXPLICIT_BZERO 1
+#    define HAVE_EXPLICIT_BZERO 1
 #elif defined(__GLIBC__) && defined(__GLIBC_PREREQ) && defined(_GNU_SOURCE)
-#if __GLIBC_PREREQ(2, 25)
-#define HAVE_EXPLICIT_BZERO 1
-#endif
+#    if __GLIBC_PREREQ(2, 25)
+#        define HAVE_EXPLICIT_BZERO 1
+#    endif
 #endif
 
 #define COMPILER_ASSERT(X) (void) sizeof(char[(X) ? 1 : -1])
@@ -164,7 +164,7 @@ store16_le(uint8_t dst[2], uint16_t w)
 #else
     dst[0] = (uint8_t) w;
     w >>= 8;
-    dst[1]     = (uint8_t) w;
+    dst[1] = (uint8_t) w;
 #endif
 }
 
@@ -246,7 +246,7 @@ store32_be(uint8_t dst[4], uint32_t w)
     w >>= 8;
     dst[1] = (uint8_t) w;
     w >>= 8;
-    dst[0]     = (uint8_t) w;
+    dst[0] = (uint8_t) w;
 #endif
 }
 
@@ -281,7 +281,7 @@ store16_be(uint8_t dst[2], uint16_t w)
 static inline void
 mem_cpy(void *__restrict__ dst_, const void *__restrict__ src_, size_t n)
 {
-    unsigned char *      dst = (unsigned char *) dst_;
+    unsigned char       *dst = (unsigned char *) dst_;
     const unsigned char *src = (const unsigned char *) src_;
     size_t               i;
 
@@ -304,7 +304,7 @@ mem_zero(void *dst_, size_t n)
 static inline void
 mem_xor(void *__restrict__ dst_, const void *__restrict__ src_, size_t n)
 {
-    unsigned char *      dst = (unsigned char *) dst_;
+    unsigned char       *dst = (unsigned char *) dst_;
     const unsigned char *src = (const unsigned char *) src_;
     size_t               i;
 
@@ -317,7 +317,7 @@ static inline void
 mem_xor2(void *__restrict__ dst_, const void *__restrict__ src1_, const void *__restrict__ src2_,
          size_t n)
 {
-    unsigned char *      dst  = (unsigned char *) dst_;
+    unsigned char       *dst  = (unsigned char *) dst_;
     const unsigned char *src1 = (const unsigned char *) src1_;
     const unsigned char *src2 = (const unsigned char *) src2_;
     size_t               i;

impl/gimli-core.h

@@ -1,7 +1,7 @@
 #ifdef __SSE2__
-#include "gimli-core/sse2.h"
+#    include "gimli-core/sse2.h"
 #else
-#include "gimli-core/portable.h"
+#    include "gimli-core/portable.h"
 #endif
 
 static void

impl/hash.h

@@ -2,7 +2,7 @@ int
 hydro_hash_update(hydro_hash_state *state, const void *in_, size_t in_len)
 {
     const uint8_t *in  = (const uint8_t *) in_;
-    uint8_t *      buf = (uint8_t *) (void *) state->state;
+    uint8_t       *buf = (uint8_t *) (void *) state->state;
     size_t         left;
     size_t         ps;
     size_t         i;
@@ -46,7 +46,7 @@ hydro_hash_init(hydro_hash_state *state, const char ctx[hydro_hash_CONTEXTBYTES]
         p = (gimli_RATE + 1 + hydro_hash_KEYBYTES + (gimli_RATE - 1)) & ~(size_t) (gimli_RATE - 1);
     } else {
         block[gimli_RATE] = (uint8_t) 0;
-        p = (gimli_RATE + 1 + 0 + (gimli_RATE - 1)) & ~(size_t) (gimli_RATE - 1);
+        p                 = (gimli_RATE + 1 + 0 + (gimli_RATE - 1)) & ~(size_t) (gimli_RATE - 1);
     }
     mem_zero(state, sizeof *state);
     hydro_hash_update(state, block, p);
@@ -74,7 +74,7 @@ hydro_hash_init_with_tweak(hydro_hash_state *state, const char ctx[hydro_hash_CO
         p = (gimli_RATE + 1 + hydro_hash_KEYBYTES + (gimli_RATE - 1)) & ~(size_t) (gimli_RATE - 1);
     } else {
         block[gimli_RATE] = (uint8_t) 0;
-        p = (gimli_RATE + 1 + 0 + (gimli_RATE - 1)) & ~(size_t) (gimli_RATE - 1);
+        p                 = (gimli_RATE + 1 + 0 + (gimli_RATE - 1)) & ~(size_t) (gimli_RATE - 1);
     }
     block[p] = (uint8_t) sizeof tweak;
     STORE64_LE(&block[p + 1], tweak);
@@ -124,7 +124,7 @@ hydro_hash_hash(uint8_t *out, size_t out_len, const void *in_, size_t in_len,
                 const char ctx[hydro_hash_CONTEXTBYTES], const uint8_t key[hydro_hash_KEYBYTES])
 {
     hydro_hash_state st;
-    const uint8_t *  in = (const uint8_t *) in_;
+    const uint8_t   *in = (const uint8_t *) in_;
 
     if (hydro_hash_init(&st, ctx, key) != 0 || hydro_hash_update(&st, in, in_len) != 0 ||
         hydro_hash_final(&st, out, out_len) != 0) {

impl/kx.h

@@ -79,8 +79,8 @@ hydro_kx_aead_encrypt(hydro_kx_state *state, uint8_t *c, const uint8_t *m, size_
 {
     _hydro_attr_aligned_(16) uint8_t aead_state[gimli_BLOCKBYTES];
     uint8_t                          k[hydro_kx_AEAD_KEYBYTES];
-    uint8_t *                        mac = &c[0];
-    uint8_t *                        ct  = &c[hydro_kx_AEAD_MACBYTES];
+    uint8_t                         *mac = &c[0];
+    uint8_t                         *ct  = &c[hydro_kx_AEAD_MACBYTES];
 
     hydro_kx_aead_init(aead_state, k, state);
     hydro_kx_aead_xor_enc(aead_state, ct, m, mlen);
@@ -99,9 +99,9 @@ hydro_kx_aead_decrypt(hydro_kx_state *state, uint8_t *m, const uint8_t *c, size_
     _hydro_attr_aligned_(16) uint32_t int_state[gimli_BLOCKBYTES / 4];
     uint32_t                          pub_mac[hydro_kx_AEAD_MACBYTES / 4];
     uint8_t                           k[hydro_kx_AEAD_KEYBYTES];
-    uint8_t *                         aead_state = (uint8_t *) (void *) int_state;
-    const uint8_t *                   mac;
-    const uint8_t *                   ct;
+    uint8_t                          *aead_state = (uint8_t *) (void *) int_state;
+    const uint8_t                    *mac;
+    const uint8_t                    *ct;
     size_t                            mlen;
     uint32_t                          cv;
 
@@ -197,8 +197,8 @@ hydro_kx_n_1(hydro_kx_session_keypair *kp, uint8_t packet1[hydro_kx_N_PACKET1BYT
              const uint8_t peer_static_pk[hydro_kx_PUBLICKEYBYTES])
 {
     hydro_kx_state state;
-    uint8_t *      packet1_eph_pk = &packet1[0];
-    uint8_t *      packet1_mac    = &packet1[hydro_kx_PUBLICKEYBYTES];
+    uint8_t       *packet1_eph_pk = &packet1[0];
+    uint8_t       *packet1_mac    = &packet1[hydro_kx_PUBLICKEYBYTES];
 
     if (psk == NULL) {
         psk = zero;
@@ -278,8 +278,8 @@ hydro_kx_kk_2(hydro_kx_session_keypair *kp, uint8_t packet2[hydro_kx_KK_PACKET2B
     hydro_kx_state state;
     const uint8_t *peer_eph_pk    = &packet1[0];
     const uint8_t *packet1_mac    = &packet1[hydro_kx_PUBLICKEYBYTES];
-    uint8_t *      packet2_eph_pk = &packet2[0];
-    uint8_t *      packet2_mac    = &packet2[hydro_kx_PUBLICKEYBYTES];
+    uint8_t       *packet2_eph_pk = &packet2[0];
+    uint8_t       *packet2_mac    = &packet2[hydro_kx_PUBLICKEYBYTES];
 
     hydro_kx_init_state(&state, "Noise_KK_hydro1");
     hydro_hash_update(&state.h_st, peer_static_pk, hydro_kx_PUBLICKEYBYTES);
@@ -354,9 +354,9 @@ hydro_kx_xx_2(hydro_kx_state *state, uint8_t packet2[hydro_kx_XX_PACKET2BYTES],
 {
     const uint8_t *peer_eph_pk           = &packet1[0];
     const uint8_t *packet1_mac           = &packet1[hydro_kx_PUBLICKEYBYTES];
-    uint8_t *      packet2_eph_pk        = &packet2[0];
-    uint8_t *      packet2_enc_static_pk = &packet2[hydro_kx_PUBLICKEYBYTES];
-    uint8_t *      packet2_mac =
+    uint8_t       *packet2_eph_pk        = &packet2[0];
+    uint8_t       *packet2_enc_static_pk = &packet2[hydro_kx_PUBLICKEYBYTES];
+    uint8_t       *packet2_mac =
         &packet2[hydro_kx_PUBLICKEYBYTES + hydro_kx_PUBLICKEYBYTES + hydro_kx_AEAD_MACBYTES];
 
     if (psk == NULL) {
@@ -490,8 +490,8 @@ hydro_kx_nk_2(hydro_kx_session_keypair *kp, uint8_t packet2[hydro_kx_NK_PACKET2B
     hydro_kx_state state;
     const uint8_t *peer_eph_pk    = &packet1[0];
     const uint8_t *packet1_mac    = &packet1[hydro_kx_PUBLICKEYBYTES];
-    uint8_t *      packet2_eph_pk = &packet2[0];
-    uint8_t *      packet2_mac    = &packet2[hydro_kx_PUBLICKEYBYTES];
+    uint8_t       *packet2_eph_pk = &packet2[0];
+    uint8_t       *packet2_mac    = &packet2[hydro_kx_PUBLICKEYBYTES];
 
     if (psk == NULL) {
         psk = zero;

impl/random.h

@@ -6,37 +6,37 @@ static TLS struct {
 } hydro_random_context;
 
 #if defined(AVR) && !defined(__unix__)
-# include "random/avr.h"
+#    include "random/avr.h"
 #elif (defined(ESP32) || defined(ESP8266)) && !defined(__unix__)
-# include "random/esp32.h"
+#    include "random/esp32.h"
 #elif defined(PARTICLE) && defined(PLATFORM_ID) && PLATFORM_ID > 2 && !defined(__unix__)
-# include "random/particle.h"
+#    include "random/particle.h"
 #elif defined(__ZEPHYR__)
-# include "random/zephyr.h"
+#    include "random/zephyr.h"
 #elif (defined(NRF52832_XXAA) || defined(NRF52832_XXAB)) && !defined(__unix__)
-# include "random/nrf52832.h"
+#    include "random/nrf52832.h"
 #elif defined(_WIN32)
-# include "random/windows.h"
+#    include "random/windows.h"
 #elif defined(__wasi__)
-# include "random/wasi.h"
+#    include "random/wasi.h"
 #elif defined(__linux__) && defined(__KERNEL__)
-# include "random/linux_kernel.h"
+#    include "random/linux_kernel.h"
 #elif defined(__unix__)
-# include "random/unix.h"
+#    include "random/unix.h"
 #elif defined(TARGET_LIKE_MBED)
-# include "random/mbed.h"
+#    include "random/mbed.h"
 #elif defined(RIOT_VERSION)
-# include "random/riot.h"
+#    include "random/riot.h"
 #elif defined(STM32F4) || defined(STM32L4)
-# include "random/stm32.h"
+#    include "random/stm32.h"
 #elif defined(__RTTHREAD__)
-# include "random/rtthread.h"
+#    include "random/rtthread.h"
 #elif defined(CH32V30x_D8) || defined(CH32V30x_D8C)
-# include "random/ch32.h"
+#    include "random/ch32.h"
 #elif defined(CHIBIOS)
-# include "random/chibios.h"
+#    include "random/chibios.h"
 #else
-# error Unsupported platform
+#    error Unsupported platform
 #endif
 
 static void
@@ -122,7 +122,7 @@ hydro_random_buf_deterministic(void *out, size_t out_len,
 {
     static const uint8_t             prefix[] = { 7, 'd', 'r', 'b', 'g', '2', '5', '6' };
     _hydro_attr_aligned_(16) uint8_t state[gimli_BLOCKBYTES];
-    uint8_t *                        p = (uint8_t *) out;
+    uint8_t                         *p = (uint8_t *) out;
     size_t                           i;
     size_t                           leftover;