be0c12
From 9d8948b3f8d37c4667a50f57ab2e357b1aeb4019 Mon Sep 17 00:00:00 2001
be0c12
From: Yu Watanabe <watanabe.yu+github@gmail.com>
be0c12
Date: Sun, 2 Dec 2018 07:46:33 +0100
be0c12
Subject: [PATCH] hash-funcs: make basic hash_ops typesafe
be0c12
be0c12
(cherry picked from commit 25073e5012cdb4de13d815197815c33194ff7dc9)
be0c12
be0c12
Resolves: #2037807
be0c12
---
be0c12
 src/basic/hash-funcs.c | 49 +++++++++++-------------------------------
be0c12
 src/basic/hash-funcs.h | 16 +++++++-------
be0c12
 2 files changed, 21 insertions(+), 44 deletions(-)
be0c12
be0c12
diff --git a/src/basic/hash-funcs.c b/src/basic/hash-funcs.c
be0c12
index db48437be7..0617536ea5 100644
be0c12
--- a/src/basic/hash-funcs.c
be0c12
+++ b/src/basic/hash-funcs.c
be0c12
@@ -5,21 +5,13 @@
be0c12
 #include "hash-funcs.h"
be0c12
 #include "path-util.h"
be0c12
 
be0c12
-void string_hash_func(const void *p, struct siphash *state) {
be0c12
+void string_hash_func(const char *p, struct siphash *state) {
be0c12
         siphash24_compress(p, strlen(p) + 1, state);
be0c12
 }
be0c12
 
be0c12
-int string_compare_func(const void *a, const void *b) {
be0c12
-        return strcmp(a, b);
be0c12
-}
be0c12
-
be0c12
-const struct hash_ops string_hash_ops = {
be0c12
-        .hash = string_hash_func,
be0c12
-        .compare = string_compare_func
be0c12
-};
be0c12
+DEFINE_HASH_OPS(string_hash_ops, char, string_hash_func, string_compare_func);
be0c12
 
be0c12
-void path_hash_func(const void *p, struct siphash *state) {
be0c12
-        const char *q = p;
be0c12
+void path_hash_func(const char *q, struct siphash *state) {
be0c12
         size_t n;
be0c12
 
be0c12
         assert(q);
be0c12
@@ -57,14 +49,11 @@ void path_hash_func(const void *p, struct siphash *state) {
be0c12
         }
be0c12
 }
be0c12
 
be0c12
-int path_compare_func(const void *a, const void *b) {
be0c12
+int path_compare_func(const char *a, const char *b) {
be0c12
         return path_compare(a, b);
be0c12
 }
be0c12
 
be0c12
-const struct hash_ops path_hash_ops = {
be0c12
-        .hash = path_hash_func,
be0c12
-        .compare = path_compare_func
be0c12
-};
be0c12
+DEFINE_HASH_OPS(path_hash_ops, char, path_hash_func, path_compare_func);
be0c12
 
be0c12
 void trivial_hash_func(const void *p, struct siphash *state) {
be0c12
         siphash24_compress(&p, sizeof(p), state);
be0c12
@@ -79,36 +68,24 @@ const struct hash_ops trivial_hash_ops = {
be0c12
         .compare = trivial_compare_func
be0c12
 };
be0c12
 
be0c12
-void uint64_hash_func(const void *p, struct siphash *state) {
be0c12
+void uint64_hash_func(const uint64_t *p, struct siphash *state) {
be0c12
         siphash24_compress(p, sizeof(uint64_t), state);
be0c12
 }
be0c12
 
be0c12
-int uint64_compare_func(const void *_a, const void *_b) {
be0c12
-        uint64_t a, b;
be0c12
-        a = *(const uint64_t*) _a;
be0c12
-        b = *(const uint64_t*) _b;
be0c12
-        return a < b ? -1 : (a > b ? 1 : 0);
be0c12
+int uint64_compare_func(const uint64_t *a, const uint64_t *b) {
be0c12
+        return CMP(*a, *b);
be0c12
 }
be0c12
 
be0c12
-const struct hash_ops uint64_hash_ops = {
be0c12
-        .hash = uint64_hash_func,
be0c12
-        .compare = uint64_compare_func
be0c12
-};
be0c12
+DEFINE_HASH_OPS(uint64_hash_ops, uint64_t, uint64_hash_func, uint64_compare_func);
be0c12
 
be0c12
 #if SIZEOF_DEV_T != 8
be0c12
-void devt_hash_func(const void *p, struct siphash *state) {
be0c12
+void devt_hash_func(const dev_t *p, struct siphash *state) {
be0c12
         siphash24_compress(p, sizeof(dev_t), state);
be0c12
 }
be0c12
 
be0c12
-int devt_compare_func(const void *_a, const void *_b) {
be0c12
-        dev_t a, b;
be0c12
-        a = *(const dev_t*) _a;
be0c12
-        b = *(const dev_t*) _b;
be0c12
-        return a < b ? -1 : (a > b ? 1 : 0);
be0c12
+int devt_compare_func(const dev_t *a, const dev_t *b) {
be0c12
+        return CMP(*a, *b);
be0c12
 }
be0c12
 
be0c12
-const struct hash_ops devt_hash_ops = {
be0c12
-        .hash = devt_hash_func,
be0c12
-        .compare = devt_compare_func
be0c12
-};
be0c12
+DEFINE_HASH_OPS(devt_hash_ops, dev_t, devt_hash_func, devt_compare_func);
be0c12
 #endif
be0c12
diff --git a/src/basic/hash-funcs.h b/src/basic/hash-funcs.h
be0c12
index 2d3125d0f9..3d2ae4b55e 100644
be0c12
--- a/src/basic/hash-funcs.h
be0c12
+++ b/src/basic/hash-funcs.h
be0c12
@@ -73,12 +73,12 @@ struct hash_ops {
be0c12
 #define DEFINE_PRIVATE_HASH_OPS_FULL(name, type, hash_func, compare_func, free_key_func, value_type, free_value_func) \
be0c12
         _DEFINE_HASH_OPS_FULL(UNIQ, name, type, hash_func, compare_func, free_key_func, value_type, free_value_func, static)
be0c12
 
be0c12
-void string_hash_func(const void *p, struct siphash *state);
be0c12
-int string_compare_func(const void *a, const void *b) _pure_;
be0c12
+void string_hash_func(const char *p, struct siphash *state);
be0c12
+#define string_compare_func strcmp
be0c12
 extern const struct hash_ops string_hash_ops;
be0c12
 
be0c12
-void path_hash_func(const void *p, struct siphash *state);
be0c12
-int path_compare_func(const void *a, const void *b) _pure_;
be0c12
+void path_hash_func(const char *p, struct siphash *state);
be0c12
+int path_compare_func(const char *a, const char *b) _pure_;
be0c12
 extern const struct hash_ops path_hash_ops;
be0c12
 
be0c12
 /* This will compare the passed pointers directly, and will not dereference them. This is hence not useful for strings
be0c12
@@ -89,15 +89,15 @@ extern const struct hash_ops trivial_hash_ops;
be0c12
 
be0c12
 /* 32bit values we can always just embed in the pointer itself, but in order to support 32bit archs we need store 64bit
be0c12
  * values indirectly, since they don't fit in a pointer. */
be0c12
-void uint64_hash_func(const void *p, struct siphash *state);
be0c12
-int uint64_compare_func(const void *a, const void *b) _pure_;
be0c12
+void uint64_hash_func(const uint64_t *p, struct siphash *state);
be0c12
+int uint64_compare_func(const uint64_t *a, const uint64_t *b) _pure_;
be0c12
 extern const struct hash_ops uint64_hash_ops;
be0c12
 
be0c12
 /* On some archs dev_t is 32bit, and on others 64bit. And sometimes it's 64bit on 32bit archs, and sometimes 32bit on
be0c12
  * 64bit archs. Yuck! */
be0c12
 #if SIZEOF_DEV_T != 8
be0c12
-void devt_hash_func(const void *p, struct siphash *state) _pure_;
be0c12
-int devt_compare_func(const void *a, const void *b) _pure_;
be0c12
+void devt_hash_func(const dev_t *p, struct siphash *state) _pure_;
be0c12
+int devt_compare_func(const dev_t *a, const dev_t *b) _pure_;
be0c12
 extern const struct hash_ops devt_hash_ops;
be0c12
 #else
be0c12
 #define devt_hash_func uint64_hash_func