Deprecate typedefs

Signed-off-by: Mattias Andrée <maandree@kth.se>

1 files changed, 119 insertions, 120 deletions

diff --git a/libkeccak.h b/libkeccak.h
index 7a95f91..b53d158 100644
--- a/libkeccak.h
+++ b/libkeccak.h
@@ -39,50 +39,50 @@
 
 
 /**
- * Invalid `libkeccak_spec_t.bitrate`: non-positive
+ * Invalid `struct libkeccak_spec.bitrate`: non-positive
  */
 #define LIBKECCAK_SPEC_ERROR_BITRATE_NONPOSITIVE 1
 
 /**
- * Invalid `libkeccak_spec_t.bitrate`: not a multiple of 8
+ * Invalid `struct libkeccak_spec.bitrate`: not a multiple of 8
  */
 #define LIBKECCAK_SPEC_ERROR_BITRATE_MOD_8 2
 
 /**
- * Invalid `libkeccak_spec_t.capacity`: non-positive
+ * Invalid `struct libkeccak_spec.capacity`: non-positive
  */
 #define LIBKECCAK_SPEC_ERROR_CAPACITY_NONPOSITIVE 3
 
 /**
- * Invalid `libkeccak_spec_t.capacity`: not a multiple of 8
+ * Invalid `struct libkeccak_spec.capacity`: not a multiple of 8
  */
 #define LIBKECCAK_SPEC_ERROR_CAPACITY_MOD_8 4
 
 /**
- * Invalid `libkeccak_spec_t.output`: non-positive
+ * Invalid `struct libkeccak_spec.output`: non-positive
  */
 #define LIBKECCAK_SPEC_ERROR_OUTPUT_NONPOSITIVE 5
 
 /**
- * Invalid `libkeccak_spec_t` values: `.bitrate + `.capacity`
+ * Invalid `struct libkeccak_spec` values: `.bitrate + `.capacity`
  * is greater 1600 which is the largest supported state size
  */
 #define LIBKECCAK_SPEC_ERROR_STATE_TOO_LARGE 6
 
 /**
- * Invalid `libkeccak_spec_t` values:
+ * Invalid `struct libkeccak_spec` values:
  * `.bitrate + `.capacity` is not a multiple of 25
  */
 #define LIBKECCAK_SPEC_ERROR_STATE_MOD_25 7
 
 /**
- * Invalid `libkeccak_spec_t` values: `.bitrate + `.capacity`
+ * Invalid `struct libkeccak_spec` values: `.bitrate + `.capacity`
  * is a not a 2-potent multiple of 25
  */
 #define LIBKECCAK_SPEC_ERROR_WORD_NON_2_POTENT 8
 
 /**
- * Invalid `libkeccak_spec_t` values: `.bitrate + `.capacity`
+ * Invalid `struct libkeccak_spec` values: `.bitrate + `.capacity`
  * is a not multiple of 100, and thus the word size is not
  * a multiple of 8
  */
@@ -90,65 +90,65 @@
 
 
 /**
- * Value for `libkeccak_generalised_spec_t` member that
+ * Value for `struct libkeccak_generalised_spec` member that
  * is used to automatically select the value
  */
 #define LIBKECCAK_GENERALISED_SPEC_AUTOMATIC (-65536L)
 
 
 /**
- * Invalid `libkeccak_generalised_spec_t.state_size`: non-positive
+ * Invalid `struct libkeccak_generalised_spec.state_size`: non-positive
  */
 #define LIBKECCAK_GENERALISED_SPEC_ERROR_STATE_NONPOSITIVE 1
 
 /**
- * Invalid `libkeccak_generalised_spec_t.state_size`: larger than 1600
+ * Invalid `struct libkeccak_generalised_spec.state_size`: larger than 1600
  */
 #define LIBKECCAK_GENERALISED_SPEC_ERROR_STATE_TOO_LARGE 2
 
 /**
- * Invalid `libkeccak_generalised_spec_t.state_size`: not a multiple of 25
+ * Invalid `struct libkeccak_generalised_spec.state_size`: not a multiple of 25
  */
 #define LIBKECCAK_GENERALISED_SPEC_ERROR_STATE_MOD_25 3
 
 /**
- * Invalid `libkeccak_generalised_spec_t.word_size`: non-positive
+ * Invalid `struct libkeccak_generalised_spec.word_size`: non-positive
  */
 #define LIBKECCAK_GENERALISED_SPEC_ERROR_WORD_NONPOSITIVE 4
 
 /**
- * Invalid `libkeccak_generalised_spec_t.word_size`: larger than 1600 / 25
+ * Invalid `struct libkeccak_generalised_spec.word_size`: larger than 1600 / 25
  */
 #define LIBKECCAK_GENERALISED_SPEC_ERROR_WORD_TOO_LARGE 5
 
 /**
- * Invalid `libkeccak_generalised_spec_t.word_size` and
- * `libkeccak_generalised_spec_t.state_size`: `.word_size * 25 != .state_size`
+ * Invalid `struct libkeccak_generalised_spec.word_size` and
+ * `struct libkeccak_generalised_spec.state_size`: `.word_size * 25 != .state_size`
  */
 #define LIBKECCAK_GENERALISED_SPEC_ERROR_STATE_WORD_INCOHERENCY 6
 
 /**
- * Invalid `libkeccak_generalised_spec_t.capacity`: non-positive
+ * Invalid `struct libkeccak_generalised_spec.capacity`: non-positive
  */
 #define LIBKECCAK_GENERALISED_SPEC_ERROR_CAPACITY_NONPOSITIVE 7
 
 /**
- * Invalid `libkeccak_generalised_spec_t.capacity`: not a multiple of 8
+ * Invalid `struct libkeccak_generalised_spec.capacity`: not a multiple of 8
  */
 #define LIBKECCAK_GENERALISED_SPEC_ERROR_CAPACITY_MOD_8 8
 
 /**
- * Invalid `libkeccak_generalised_spec_t.bitrate`: non-positive
+ * Invalid `struct libkeccak_generalised_spec.bitrate`: non-positive
  */
 #define LIBKECCAK_GENERALISED_SPEC_ERROR_BITRATE_NONPOSITIVE 9
 
 /**
- * Invalid `libkeccak_generalised_spec_t.bitrate`: not a multiple of 8
+ * Invalid `struct libkeccak_generalised_spec.bitrate`: not a multiple of 8
  */
 #define LIBKECCAK_GENERALISED_SPEC_ERROR_BITRATE_MOD_8 10
 
 /**
- * Invalid `libkeccak_generalised_spec_t.output`: non-positive
+ * Invalid `struct libkeccak_generalised_spec.output`: non-positive
  */
 #define LIBKECCAK_GENERALISED_SPEC_ERROR_OUTPUT_NONPOSITIVE 11
 
@@ -157,7 +157,7 @@
  * Data structure that describes the parameters
  * that should be used when hashing
  */
-typedef struct libkeccak_spec {
+struct libkeccak_spec {
 	/**
 	 * The bitrate
 	 */
@@ -172,15 +172,13 @@ typedef struct libkeccak_spec {
 	 * The output size
 	 */
 	long int output;
-
-} libkeccak_spec_t;
+};
 
 /**
  * Generalised datastructure that describes the
  * parameters that should be used when hashing
  */
-typedef struct libkeccak_generalised_spec
-{
+struct libkeccak_generalised_spec {
 	/**
 	 * The bitrate
 	 */
@@ -205,15 +203,14 @@ typedef struct libkeccak_generalised_spec
 	 * The word size
 	 */
 	long int word_size;
-
-} libkeccak_generalised_spec_t;
+};
 
 /**
  * Data structure that describes the state of a hashing process
  * 
  * The `char`-size of the output hashsum is calculated by `(.n + 7) / 8`
  */
-typedef struct libkeccak_state {
+struct libkeccak_state {
 	/**
 	 * The lanes (state/sponge)
 	 */
@@ -273,19 +270,18 @@ typedef struct libkeccak_state {
 	 * Left over water to fill the sponge with at next update
 	 */
 	char *M;
-
-} libkeccak_state_t;
+};
 
 
 /**
- * Fill in a `libkeccak_spec_t` for a SHA3-x hashing
+ * Fill in a `struct libkeccak_spec` for a SHA3-x hashing
  * 
  * @param  spec  The specifications datastructure to fill in
  * @param  x     The value of x in `SHA3-x`, the output size
  */
-LIBKECCAK_GCC_ONLY(__attribute__((nonnull, nothrow)))
+LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __nothrow__)))
 static inline void
-libkeccak_spec_sha3(libkeccak_spec_t *restrict spec, long int x)
+libkeccak_spec_sha3(struct libkeccak_spec *restrict spec, long int x)
 {
 	spec->bitrate = 1600 - 2 * x;
 	spec->capacity = 2 * x;
@@ -293,15 +289,15 @@ libkeccak_spec_sha3(libkeccak_spec_t *restrict spec, long int x)
 }
 
 /**
- * Fill in a `libkeccak_spec_t` for a RawSHAKEx hashing
+ * Fill in a `struct libkeccak_spec` for a RawSHAKEx hashing
  * 
  * @param  spec  The specifications datastructure to fill in
  * @param  x     The value of x in `RawSHAKEx`, half the capacity
  * @param  d     The output size
  */
-LIBKECCAK_GCC_ONLY(__attribute__((nonnull, nothrow)))
+LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __nothrow__)))
 static inline void
-libkeccak_spec_rawshake(libkeccak_spec_t *restrict spec, long int x, long int d)
+libkeccak_spec_rawshake(struct libkeccak_spec *restrict spec, long int x, long int d)
 {
 	spec->bitrate = 1600 - 2 * x;
 	spec->capacity = 2 * x;
@@ -309,26 +305,27 @@ libkeccak_spec_rawshake(libkeccak_spec_t *restrict spec, long int x, long int d)
 }
 
 /**
- * Fill in a `libkeccak_spec_t` for a SHAKEx hashing
+ * Fill in a `struct libkeccak_spec` for a SHAKEx hashing
  * 
- * @param  spec:libkeccak_spec_t*  The specifications datastructure to fill in
- * @param  x:long                  The value of x in `SHAKEx`, half the capacity
- * @param  d:long                  The output size
+ * @param  spec:struct libkeccak_spec *  The specifications datastructure to fill in
+ * @param  x:long                        The value of x in `SHAKEx`, half the capacity
+ * @param  d:long                        The output size
  */
 #define libkeccak_spec_shake libkeccak_spec_rawshake
 
 /**
- * Check for errors in a `libkeccak_spec_t`
+ * Check for errors in a `struct libkeccak_spec`
  * 
  * @param   spec  The specifications datastructure to check
  * @return        Zero if error free, a `LIBKECCAK_SPEC_ERROR_*` if an error was found
  */
-LIBKECCAK_GCC_ONLY(__attribute__((nonnull, nothrow, unused, warn_unused_result, pure)))
+LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __nothrow__, __unused__, __warn_unused_result__, __pure__)))
 static inline int
-libkeccak_spec_check(const libkeccak_spec_t *restrict spec)
+libkeccak_spec_check(const struct libkeccak_spec *restrict spec)
 {
 	long int state_size = spec->capacity + spec->bitrate;
 	int32_t word_size = (int32_t)(state_size / 25);
+
 	if (spec->bitrate <= 0)  return LIBKECCAK_SPEC_ERROR_BITRATE_NONPOSITIVE;
 	if (spec->bitrate % 8)   return LIBKECCAK_SPEC_ERROR_BITRATE_MOD_8;
 	if (spec->capacity <= 0) return LIBKECCAK_SPEC_ERROR_CAPACITY_NONPOSITIVE;
@@ -355,7 +352,7 @@ libkeccak_spec_check(const libkeccak_spec_t *restrict spec)
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __nothrow__, __unused__)))
 static inline void
-libkeccak_generalised_spec_initialise(libkeccak_generalised_spec_t *restrict spec)
+libkeccak_generalised_spec_initialise(struct libkeccak_generalised_spec *restrict spec)
 {
 	spec->bitrate    = LIBKECCAK_GENERALISED_SPEC_AUTOMATIC;
 	spec->capacity   = LIBKECCAK_GENERALISED_SPEC_AUTOMATIC;
@@ -365,14 +362,14 @@ libkeccak_generalised_spec_initialise(libkeccak_generalised_spec_t *restrict spe
 }
 
 /**
- * Convert a `libkeccak_generalised_spec_t` to a `libkeccak_spec_t`
+ * Convert a `struct libkeccak_generalised_spec` to a `struct libkeccak_spec`
  * 
  * @param   spec         The generalised input specifications, will be update with resolved automatic values
  * @param   output_spec  The specification datastructure to fill in
  * @return               Zero if `spec` is valid, a `LIBKECCAK_GENERALISED_SPEC_ERROR_*` if an error was found
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__leaf__, __nonnull__, __nothrow__)))
-int libkeccak_degeneralise_spec(libkeccak_generalised_spec_t *restrict, libkeccak_spec_t *restrict);
+int libkeccak_degeneralise_spec(struct libkeccak_generalised_spec *restrict, struct libkeccak_spec *restrict);
 
 /**
  * Initialise a state according to hashing specifications
@@ -382,7 +379,7 @@ int libkeccak_degeneralise_spec(libkeccak_generalised_spec_t *restrict, libkecca
  * @return         Zero on success, -1 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__leaf__, __nonnull__)))
-int libkeccak_state_initialise(libkeccak_state_t *restrict, const libkeccak_spec_t *restrict);
+int libkeccak_state_initialise(struct libkeccak_state *restrict, const struct libkeccak_spec *restrict);
 
 /**
  * Reset a state according to hashing specifications
@@ -391,7 +388,7 @@ int libkeccak_state_initialise(libkeccak_state_t *restrict, const libkeccak_spec
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __nothrow__, __unused__)))
 static inline void
-libkeccak_state_reset(libkeccak_state_t *restrict state)
+libkeccak_state_reset(struct libkeccak_state *restrict state)
 {
 	state->mptr = 0;
 	memset(state->S, 0, sizeof(state->S));
@@ -403,7 +400,7 @@ libkeccak_state_reset(libkeccak_state_t *restrict state)
  * @param  state  The state that should be destroyed
  */
 static inline void
-libkeccak_state_fast_destroy(libkeccak_state_t *restrict state)
+libkeccak_state_fast_destroy(struct libkeccak_state *restrict state)
 {
 	if (state) {
 		free(state->M);
@@ -417,7 +414,7 @@ libkeccak_state_fast_destroy(libkeccak_state_t *restrict state)
  * @param  state  The state that should be wipe
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__leaf__, __nonnull__, __nothrow__, __optimize__("-O0"))))
-void libkeccak_state_wipe_message(volatile libkeccak_state_t *restrict);
+void libkeccak_state_wipe_message(volatile struct libkeccak_state *restrict);
 
 /**
  * Wipe data in the state's sponge wihout freeing any data
@@ -425,7 +422,7 @@ void libkeccak_state_wipe_message(volatile libkeccak_state_t *restrict);
  * @param  state  The state that should be wipe
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__leaf__, __nonnull__, __nothrow__, __optimize__("-O0"))))
-void libkeccak_state_wipe_sponge(volatile libkeccak_state_t *restrict);
+void libkeccak_state_wipe_sponge(volatile struct libkeccak_state *restrict);
 
 /**
  * Wipe sensitive data wihout freeing any data
@@ -433,7 +430,7 @@ void libkeccak_state_wipe_sponge(volatile libkeccak_state_t *restrict);
  * @param  state  The state that should be wipe
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __nothrow__, __optimize__("-O0"))))
-void libkeccak_state_wipe(volatile libkeccak_state_t *restrict);
+void libkeccak_state_wipe(volatile struct libkeccak_state *restrict);
 
 /**
  * Release resources allocation for a state and wipe sensitive data
@@ -442,7 +439,7 @@ void libkeccak_state_wipe(volatile libkeccak_state_t *restrict);
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__unused__, __optimize__("-O0"))))
 static inline void
-libkeccak_state_destroy(volatile libkeccak_state_t *restrict state)
+libkeccak_state_destroy(volatile struct libkeccak_state *restrict state)
 {
 	if (state) {
 		libkeccak_state_wipe(state);
@@ -458,10 +455,10 @@ libkeccak_state_destroy(volatile libkeccak_state_t *restrict state)
  * @return        The state, `NULL` on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __unused__, __warn_unused_result__, __malloc__)))
-static inline libkeccak_state_t *
-libkeccak_state_create(const libkeccak_spec_t *restrict spec)
+static inline struct libkeccak_state *
+libkeccak_state_create(const struct libkeccak_spec *restrict spec)
 {
-	libkeccak_state_t *restrict state = malloc(sizeof(libkeccak_state_t));
+	struct libkeccak_state *restrict state = malloc(sizeof(struct libkeccak_state));
 	if (!state || libkeccak_state_initialise(state, spec)) {
 		free(state);
 		return NULL;
@@ -476,7 +473,7 @@ libkeccak_state_create(const libkeccak_spec_t *restrict spec)
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__unused__)))
 static inline void
-libkeccak_state_fast_free(libkeccak_state_t *restrict state)
+libkeccak_state_fast_free(struct libkeccak_state *restrict state)
 {
 	libkeccak_state_fast_destroy(state);
 	free(state);
@@ -489,14 +486,14 @@ libkeccak_state_fast_free(libkeccak_state_t *restrict state)
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__unused__, __optimize__("-O0"))))
 static inline void
-libkeccak_state_free(volatile libkeccak_state_t *restrict state)
+libkeccak_state_free(volatile struct libkeccak_state *restrict state)
 {
 #ifdef __GNUC__
 # pragma GCC diagnostic push
 # pragma GCC diagnostic ignored "-Wcast-qual"
 #endif
 	libkeccak_state_destroy(state);
-	free((libkeccak_state_t *)state);
+	free((struct libkeccak_state *)state);
 #ifdef __GNUC__
 # pragma GCC diagnostic pop
 #endif
@@ -510,7 +507,7 @@ libkeccak_state_free(volatile libkeccak_state_t *restrict state)
  * @return        Zero on success, -1 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__leaf__, __nonnull__)))
-int libkeccak_state_copy(libkeccak_state_t *restrict, const libkeccak_state_t *restrict);
+int libkeccak_state_copy(struct libkeccak_state *restrict, const struct libkeccak_state *restrict);
 
 /**
  * A wrapper for `libkeccak_state_copy` that also allocates the duplicate
@@ -519,10 +516,10 @@ int libkeccak_state_copy(libkeccak_state_t *restrict, const libkeccak_state_t *r
  * @return       The duplicate, `NULL` on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __unused__, __warn_unused_result__, __malloc__)))
-static inline libkeccak_state_t *
-libkeccak_state_duplicate(const libkeccak_state_t *restrict src)
+static inline struct libkeccak_state *
+libkeccak_state_duplicate(const struct libkeccak_state *restrict src)
 {
-	libkeccak_state_t *restrict dest = malloc(sizeof(libkeccak_state_t));
+	struct libkeccak_state *restrict dest = malloc(sizeof(struct libkeccak_state));
 	if (!dest || libkeccak_state_copy(dest, src)) {
 		libkeccak_state_free(dest);
 		return NULL;
@@ -539,33 +536,33 @@ libkeccak_state_duplicate(const libkeccak_state_t *restrict src)
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __nothrow__, __unused__, __warn_unused_result__, __pure__)))
 static inline size_t
-libkeccak_state_marshal_size(const libkeccak_state_t *restrict state)
+libkeccak_state_marshal_size(const struct libkeccak_state *restrict state)
 {
-	return sizeof(libkeccak_state_t) - sizeof(char *) + state->mptr * sizeof(char);
+	return sizeof(struct libkeccak_state) - sizeof(char *) + state->mptr * sizeof(char);
 }
 
 /**
- * Marshal a `libkeccak_state_t` into a buffer
+ * Marshal a `struct libkeccak_state` into a buffer
  * 
  * @param   state  The state to marshal
  * @param   data   The output buffer
  * @return         The number of bytes stored to `data`
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__leaf__, __nonnull__, __nothrow__)))
-size_t libkeccak_state_marshal(const libkeccak_state_t *restrict, void *restrict);
+size_t libkeccak_state_marshal(const struct libkeccak_state *restrict, void *restrict);
 
 /**
- * Unmarshal a `libkeccak_state_t` from a buffer
+ * Unmarshal a `struct libkeccak_state` from a buffer
  * 
  * @param   state  The slot for the unmarshalled state, must not be initialised (memory leak otherwise)
  * @param   data   The input buffer
  * @return         The number of bytes read from `data`, 0 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__leaf__, __nonnull__)))
-size_t libkeccak_state_unmarshal(libkeccak_state_t *restrict, const void *restrict);
+size_t libkeccak_state_unmarshal(struct libkeccak_state *restrict, const void *restrict);
 
 /**
- * Gets the number of bytes the `libkeccak_state_t` stored
+ * Gets the number of bytes the `struct libkeccak_state` stored
  * at the beginning of `data` occupies
  * 
  * @param   data  The data buffer
@@ -584,7 +581,7 @@ size_t libkeccak_state_unmarshal_skip(const void *restrict);
  * @return          Zero on success, -1 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__)))
-int libkeccak_fast_update(libkeccak_state_t *restrict, const void *restrict, size_t);
+int libkeccak_fast_update(struct libkeccak_state *restrict, const void *restrict, size_t);
 
 /**
  * Absorb more of the message to the Keccak sponge
@@ -596,7 +593,7 @@ int libkeccak_fast_update(libkeccak_state_t *restrict, const void *restrict, siz
  * @return          Zero on success, -1 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__)))
-int libkeccak_update(libkeccak_state_t *restrict, const void *restrict, size_t);
+int libkeccak_update(struct libkeccak_state *restrict, const void *restrict, size_t);
 
 /**
  * Absorb the last part of the message and squeeze the Keccak sponge
@@ -611,7 +608,7 @@ int libkeccak_update(libkeccak_state_t *restrict, const void *restrict, size_t);
  * @return           Zero on success, -1 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__(1))))
-int libkeccak_fast_digest(libkeccak_state_t *restrict, const void *restrict, size_t,
+int libkeccak_fast_digest(struct libkeccak_state *restrict, const void *restrict, size_t,
                           size_t, const char *restrict, void *restrict);
 
 /**
@@ -627,7 +624,7 @@ int libkeccak_fast_digest(libkeccak_state_t *restrict, const void *restrict, siz
  * @return           Zero on success, -1 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__(1))))
-int libkeccak_digest(libkeccak_state_t *restrict, const void *restrict, size_t,
+int libkeccak_digest(struct libkeccak_state *restrict, const void *restrict, size_t,
                      size_t, const char *restrict, void *restrict);
 
 /**
@@ -637,7 +634,7 @@ int libkeccak_digest(libkeccak_state_t *restrict, const void *restrict, size_t,
  * @param  times  The number of rounds
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __nothrow__)))
-void libkeccak_simple_squeeze(register libkeccak_state_t *restrict, register long int);
+void libkeccak_simple_squeeze(register struct libkeccak_state *restrict, register long int);
 
 /**
  * Squeeze as much as is needed to get a digest a number of times
@@ -646,7 +643,7 @@ void libkeccak_simple_squeeze(register libkeccak_state_t *restrict, register lon
  * @param  times  The number of digests
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __nothrow__)))
-void libkeccak_fast_squeeze(register libkeccak_state_t *restrict, register long int);
+void libkeccak_fast_squeeze(register struct libkeccak_state *restrict, register long int);
 
 /**
  * Squeeze out another digest
@@ -655,7 +652,7 @@ void libkeccak_fast_squeeze(register libkeccak_state_t *restrict, register long
  * @param  hashsum  Output parameter for the hashsum
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __nothrow__)))
-void libkeccak_squeeze(register libkeccak_state_t *restrict, register void *restrict);
+void libkeccak_squeeze(register struct libkeccak_state *restrict, register void *restrict);
 
 /**
  * Convert a binary hashsum to lower case hexadecimal representation
@@ -700,7 +697,7 @@ void libkeccak_unhex(void *restrict, const char *restrict);
  * @return           Zero on success, -1 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__(2, 3))))
-int libkeccak_generalised_sum_fd(int, libkeccak_state_t *restrict, const libkeccak_spec_t *restrict,
+int libkeccak_generalised_sum_fd(int, struct libkeccak_state *restrict, const struct libkeccak_spec *restrict,
                                  const char *restrict, void *restrict);
 
 /**
@@ -716,7 +713,8 @@ int libkeccak_generalised_sum_fd(int, libkeccak_state_t *restrict, const libkecc
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__(2, 3), __artificial__, __gnu_inline__)))
 static inline int
-libkeccak_keccaksum_fd(int fd, libkeccak_state_t *restrict state, const libkeccak_spec_t *restrict spec, void *restrict hashsum)
+libkeccak_keccaksum_fd(int fd, struct libkeccak_state *restrict state,
+                       const struct libkeccak_spec *restrict spec, void *restrict hashsum)
 {
 	return libkeccak_generalised_sum_fd(fd, state, spec, NULL, hashsum);
 }
@@ -734,9 +732,9 @@ libkeccak_keccaksum_fd(int fd, libkeccak_state_t *restrict state, const libkecca
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__(2), __artificial__, __gnu_inline__)))
 static inline int
-libkeccak_sha3sum_fd(int fd, libkeccak_state_t *restrict state, long output, void *restrict hashsum)
+libkeccak_sha3sum_fd(int fd, struct libkeccak_state *restrict state, long output, void *restrict hashsum)
 {
-	libkeccak_spec_t spec;
+	struct libkeccak_spec spec;
 	libkeccak_spec_sha3(&spec, output);
 	return libkeccak_generalised_sum_fd(fd, state, &spec, LIBKECCAK_SHA3_SUFFIX, hashsum);
 }
@@ -755,9 +753,9 @@ libkeccak_sha3sum_fd(int fd, libkeccak_state_t *restrict state, long output, voi
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__(2), __artificial__, __gnu_inline__)))
 static inline int
-libkeccak_rawshakesum_fd(int fd, libkeccak_state_t *restrict state, long semicapacity, long output, void *restrict hashsum)
+libkeccak_rawshakesum_fd(int fd, struct libkeccak_state *restrict state, long semicapacity, long output, void *restrict hashsum)
 {
-	libkeccak_spec_t spec;
+	struct libkeccak_spec spec;
 	libkeccak_spec_rawshake(&spec, semicapacity, output);
 	return libkeccak_generalised_sum_fd(fd, state, &spec, LIBKECCAK_RAWSHAKE_SUFFIX, hashsum);
 }
@@ -776,9 +774,9 @@ libkeccak_rawshakesum_fd(int fd, libkeccak_state_t *restrict state, long semicap
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__(2), __artificial__, __gnu_inline__)))
 static inline int
-libkeccak_shakesum_fd(int fd, libkeccak_state_t *restrict state, long semicapacity, long output, void *restrict hashsum)
+libkeccak_shakesum_fd(int fd, struct libkeccak_state *restrict state, long semicapacity, long output, void *restrict hashsum)
 {
-	libkeccak_spec_t spec;
+	struct libkeccak_spec spec;
 	libkeccak_spec_shake(&spec, semicapacity, output);
 	return libkeccak_generalised_sum_fd(fd, state, &spec, LIBKECCAK_SHAKE_SUFFIX, hashsum);
 }
@@ -792,10 +790,9 @@ libkeccak_shakesum_fd(int fd, libkeccak_state_t *restrict state, long semicapaci
 
 
 /**
- * Datastructure that describes the state of an HMAC-hashing process
+ * Data structure that describes the state of an HMAC-hashing process
  */
-typedef struct libkeccak_hmac_state
-{
+struct libkeccak_hmac_state {
 	/**
 	 * The key right-padded and XOR:ed with the outer pad
 	 */
@@ -816,7 +813,7 @@ typedef struct libkeccak_hmac_state
 	/**
 	 * The state of the underlaying hash-algorithm
 	 */
-	libkeccak_state_t sponge;
+	struct libkeccak_state sponge;
 
 	/**
 	 * Buffer used to temporarily store bit shift message if
@@ -835,8 +832,7 @@ typedef struct libkeccak_hmac_state
 	char leftover;
 
 	char __pad[sizeof(void *) / sizeof(char) - 1];
-
-} libkeccak_hmac_state_t;
+};
 
 
 /**
@@ -848,7 +844,7 @@ typedef struct libkeccak_hmac_state
  * @return              Zero on success, -1 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__(1))))
-int libkeccak_hmac_set_key(libkeccak_hmac_state_t *restrict, const void *restrict, size_t);
+int libkeccak_hmac_set_key(struct libkeccak_hmac_state *restrict, const void *restrict, size_t);
 
 /**
  * Initialise an HMAC hashing-state according to hashing specifications
@@ -861,7 +857,7 @@ int libkeccak_hmac_set_key(libkeccak_hmac_state_t *restrict, const void *restric
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__)))
 static inline int
-libkeccak_hmac_initialise(libkeccak_hmac_state_t *restrict state, const libkeccak_spec_t *restrict spec,
+libkeccak_hmac_initialise(struct libkeccak_hmac_state *restrict state, const struct libkeccak_spec *restrict spec,
                           const void *restrict key, size_t key_length)
 {
 	if (libkeccak_state_initialise(&state->sponge, spec) < 0)
@@ -885,10 +881,10 @@ libkeccak_hmac_initialise(libkeccak_hmac_state_t *restrict state, const libkecca
  * @return              The state, `NULL` on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __unused__, __warn_unused_result__, __malloc__)))
-static inline libkeccak_hmac_state_t *
-libkeccak_hmac_create(const libkeccak_spec_t *restrict spec, const void *restrict key, size_t key_length)
+static inline struct libkeccak_hmac_state *
+libkeccak_hmac_create(const struct libkeccak_spec *restrict spec, const void *restrict key, size_t key_length)
 {
-	libkeccak_hmac_state_t *restrict state = malloc(sizeof(libkeccak_hmac_state_t));
+	struct libkeccak_hmac_state *restrict state = malloc(sizeof(struct libkeccak_hmac_state));
 	if (!state || libkeccak_hmac_initialise(state, spec, key, key_length)) {
 		free(state);
 		return NULL;
@@ -907,7 +903,7 @@ libkeccak_hmac_create(const libkeccak_spec_t *restrict spec, const void *restric
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__(1), __unused__)))
 static inline int
-libkeccak_hmac_reset(libkeccak_hmac_state_t *restrict state, const void *restrict key, size_t key_length)
+libkeccak_hmac_reset(struct libkeccak_hmac_state *restrict state, const void *restrict key, size_t key_length)
 {
 	libkeccak_state_reset(&state->sponge);
 	return key ? libkeccak_hmac_set_key(state, key, key_length) : 0;
@@ -919,7 +915,7 @@ libkeccak_hmac_reset(libkeccak_hmac_state_t *restrict state, const void *restric
  * @param  state  The state that should be wipe
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __nothrow__, __optimize__("-O0"))))
-void libkeccak_hmac_wipe(volatile libkeccak_hmac_state_t *restrict);
+void libkeccak_hmac_wipe(volatile struct libkeccak_hmac_state *restrict);
 
 /**
  * Release resources allocation for an HMAC hashing-state without wiping sensitive data
@@ -927,7 +923,7 @@ void libkeccak_hmac_wipe(volatile libkeccak_hmac_state_t *restrict);
  * @param  state  The state that should be destroyed
  */
 static inline void
-libkeccak_hmac_fast_destroy(libkeccak_hmac_state_t *restrict state)
+libkeccak_hmac_fast_destroy(struct libkeccak_hmac_state *restrict state)
 {
 	if (!state)
 		return;
@@ -947,10 +943,10 @@ libkeccak_hmac_fast_destroy(libkeccak_hmac_state_t *restrict state)
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__unused__, __optimize__("-O0"))))
 static inline void
-libkeccak_hmac_destroy(volatile libkeccak_hmac_state_t *restrict state)
+libkeccak_hmac_destroy(volatile struct libkeccak_hmac_state *restrict state)
 {
 	if (!state)
-	  return;
+		return;
 	libkeccak_hmac_wipe(state);
 	free(state->key_opad);
 	state->key_opad = NULL;
@@ -969,7 +965,7 @@ libkeccak_hmac_destroy(volatile libkeccak_hmac_state_t *restrict state)
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__unused__)))
 static inline void
-libkeccak_hmac_fast_free(libkeccak_hmac_state_t *restrict state)
+libkeccak_hmac_fast_free(struct libkeccak_hmac_state *restrict state)
 {
 	libkeccak_hmac_fast_destroy(state);
 	free(state);
@@ -982,14 +978,14 @@ libkeccak_hmac_fast_free(libkeccak_hmac_state_t *restrict state)
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__unused__, __optimize__("-O0"))))
 static inline void
-libkeccak_hmac_free(volatile libkeccak_hmac_state_t *restrict state)
+libkeccak_hmac_free(volatile struct libkeccak_hmac_state *restrict state)
 {
 #ifdef __GNUC__
 # pragma GCC diagnostic push
 # pragma GCC diagnostic ignored "-Wcast-qual"
 #endif
 	libkeccak_hmac_destroy(state);
-	free((libkeccak_hmac_state_t*)state);
+	free((struct libkeccak_hmac_state*)state);
 #ifdef __GNUC__
 # pragma GCC diagnostic pop
 #endif
@@ -1003,7 +999,7 @@ libkeccak_hmac_free(volatile libkeccak_hmac_state_t *restrict state)
  * @return        Zero on success, -1 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__)))
-int libkeccak_hmac_copy(libkeccak_hmac_state_t *restrict, const libkeccak_hmac_state_t *restrict);
+int libkeccak_hmac_copy(struct libkeccak_hmac_state *restrict, const struct libkeccak_hmac_state *restrict);
 
 /**
  * A wrapper for `libkeccak_hmac_copy` that also allocates the duplicate
@@ -1012,10 +1008,10 @@ int libkeccak_hmac_copy(libkeccak_hmac_state_t *restrict, const libkeccak_hmac_s
  * @return       The duplicate, `NULL` on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __unused__, __warn_unused_result__, __malloc__)))
-static inline libkeccak_hmac_state_t *
-libkeccak_hmac_duplicate(const libkeccak_hmac_state_t *restrict src)
+static inline struct libkeccak_hmac_state *
+libkeccak_hmac_duplicate(const struct libkeccak_hmac_state *restrict src)
 {
-	libkeccak_hmac_state_t* restrict dest = malloc(sizeof(libkeccak_hmac_state_t));
+	struct libkeccak_hmac_state* restrict dest = malloc(sizeof(struct libkeccak_hmac_state));
 	if (!dest || libkeccak_hmac_copy(dest, src))
 		return libkeccak_hmac_free(dest), NULL;
 	return dest;
@@ -1030,14 +1026,14 @@ libkeccak_hmac_duplicate(const libkeccak_hmac_state_t *restrict src)
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __nothrow__, __unused__, __warn_unused_result__, __pure__)))
 static inline size_t
-libkeccak_hmac_marshal_size(const libkeccak_hmac_state_t *restrict state)
+libkeccak_hmac_marshal_size(const struct libkeccak_hmac_state *restrict state)
 {
 	return libkeccak_state_marshal_size(&state->sponge) + sizeof(size_t) +
 	       ((state->key_length + 7) >> 3) + 2 * sizeof(char);
 }
 
 /**
- * Marshal a `libkeccak_hmac_state_t` into a buffer
+ * Marshal a `struct libkeccak_hmac_state` into a buffer
  * 
  * @param   state  The state to marshal
  * @param   data   The output buffer
@@ -1045,7 +1041,7 @@ libkeccak_hmac_marshal_size(const libkeccak_hmac_state_t *restrict state)
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__, __nothrow__)))
 static inline size_t
-libkeccak_hmac_marshal(const libkeccak_hmac_state_t *restrict state, void *restrict data_)
+libkeccak_hmac_marshal(const struct libkeccak_hmac_state *restrict state, void *restrict data_)
 {
 	char *restrict data = data_;
 	size_t written = libkeccak_state_marshal(&state->sponge, data);
@@ -1060,17 +1056,17 @@ libkeccak_hmac_marshal(const libkeccak_hmac_state_t *restrict state, void *restr
 }
 
 /**
- * Unmarshal a `libkeccak_hmac_state_t` from a buffer
+ * Unmarshal a `struct libkeccak_hmac_state` from a buffer
  * 
  * @param   state  The slot for the unmarshalled state, must not be initialised (memory leak otherwise)
  * @param   data   The input buffer
  * @return         The number of bytes read from `data`, 0 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__)))
-size_t libkeccak_hmac_unmarshal(libkeccak_hmac_state_t *restrict, const void *restrict);
+size_t libkeccak_hmac_unmarshal(struct libkeccak_hmac_state *restrict, const void *restrict);
 
 /**
- * Gets the number of bytes the `libkeccak_hmac_state_t` stored
+ * Gets the number of bytes the `struct libkeccak_hmac_state` stored
  * at the beginning of `data` occupies
  * 
  * @param   data  The data buffer
@@ -1096,7 +1092,7 @@ libkeccak_hmac_unmarshal_skip(const void *restrict data_)
  * @return          Zero on success, -1 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__(1))))
-int libkeccak_hmac_fast_update(libkeccak_hmac_state_t *restrict state, const void *restrict msg, size_t msglen);
+int libkeccak_hmac_fast_update(struct libkeccak_hmac_state *restrict state, const void *restrict msg, size_t msglen);
 
 /**
  * Absorb more, or the first part, of the message
@@ -1108,7 +1104,7 @@ int libkeccak_hmac_fast_update(libkeccak_hmac_state_t *restrict state, const voi
  * @return          Zero on success, -1 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__(1))))
-int libkeccak_hmac_update(libkeccak_hmac_state_t *restrict state, const void *restrict msg, size_t msglen);
+int libkeccak_hmac_update(struct libkeccak_hmac_state *restrict state, const void *restrict msg, size_t msglen);
 
 /**
  * Absorb the last part of the message and fetch the hash
@@ -1125,7 +1121,7 @@ int libkeccak_hmac_update(libkeccak_hmac_state_t *restrict state, const void *re
  * @return           Zero on success, -1 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__(1))))
-int libkeccak_hmac_fast_digest(libkeccak_hmac_state_t *restrict state, const void *restrict msg, size_t msglen,
+int libkeccak_hmac_fast_digest(struct libkeccak_hmac_state *restrict state, const void *restrict msg, size_t msglen,
                                size_t bits, const char *restrict suffix, void *restrict hashsum);
 
 /**
@@ -1143,8 +1139,11 @@ int libkeccak_hmac_fast_digest(libkeccak_hmac_state_t *restrict state, const voi
  * @return           Zero on success, -1 on error
  */
 LIBKECCAK_GCC_ONLY(__attribute__((__nonnull__(1))))
-int libkeccak_hmac_digest(libkeccak_hmac_state_t *restrict state, const void *restrict msg, size_t msglen,
+int libkeccak_hmac_digest(struct libkeccak_hmac_state *restrict state, const void *restrict msg, size_t msglen,
                           size_t bits, const char *restrict suffix, void *restrict hashsum);
 
 
+#include "libkeccak-legacy.h"
+
+
 #endif