add t1ha2 hash and test results

hash_testing/new_testing/hash_funcs/t1ha2/bin_hash.c

@@ -0,0 +1,113 @@
+/*
+ * Standalone t1ha2_atonce command-line wrapper for avalanche testing.
+ *
+ * Upstream: https://gitflic.ru/project/erthink/t1ha
+ * Commit: 00eb779b6c042ccd831ec2f1ae757409c73f39f6
+ * Algorithm: t1ha2_atonce(data, length, seed=0), stable portable 64-bit mode.
+ *
+ * The vendored upstream implementation is licensed under the zlib License;
+ * see upstream/LICENSE. This wrapper is an altered integration file and is not
+ * represented as an original upstream source file.
+ */
+
+#include <inttypes.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define T1HA0_DISABLED
+#define T1HA1_DISABLED
+#define T1HA_SYS_UNALIGNED_ACCESS 0
+#define T1HA_USE_FAST_ONESHOT_READ 0
+#include "upstream/src/t1ha2.c"
+
+#define T1HA2_SEED UINT64_C(0)
+
+static int is_ascii_trailing_space(unsigned char character)
+{
+    return character == ' ' || character == '\t' || character == '\n' ||
+           character == '\r' || character == '\v' || character == '\f';
+}
+
+static int read_stdin(unsigned char **data, size_t *length)
+{
+    size_t capacity = 256;
+    unsigned char *buffer = malloc(capacity);
+
+    if (buffer == NULL) {
+        return -1;
+    }
+
+    *length = 0;
+    for (;;) {
+        size_t available = capacity - *length;
+        size_t bytes_read = fread(buffer + *length, 1, available, stdin);
+        *length += bytes_read;
+
+        if (bytes_read < available) {
+            if (ferror(stdin)) {
+                free(buffer);
+                return -1;
+            }
+            break;
+        }
+
+        if (capacity > SIZE_MAX / 2U) {
+            free(buffer);
+            return -1;
+        }
+        capacity *= 2U;
+
+        {
+            unsigned char *larger_buffer = realloc(buffer, capacity);
+            if (larger_buffer == NULL) {
+                free(buffer);
+                return -1;
+            }
+            buffer = larger_buffer;
+        }
+    }
+
+    *data = buffer;
+    return 0;
+}
+
+int main(int argc, char **argv)
+{
+    const unsigned char *word;
+    unsigned char *stdin_buffer = NULL;
+    size_t length;
+
+    if (argc > 2) {
+        fprintf(stderr, "usage: %s [ASCII_WORD]\n", argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    if (argc == 2) {
+        word = (const unsigned char *)argv[1];
+        length = strlen(argv[1]);
+    } else {
+        if (read_stdin(&stdin_buffer, &length) != 0) {
+            fprintf(stderr, "failed to read input\n");
+            return EXIT_FAILURE;
+        }
+        word = stdin_buffer;
+    }
+
+    while (length > 0U && is_ascii_trailing_space(word[length - 1U])) {
+        --length;
+    }
+
+    for (size_t index = 0; index < length; ++index) {
+        if (word[index] > 0x7fU) {
+            fprintf(stderr, "input must contain ASCII characters only\n");
+            free(stdin_buffer);
+            return EXIT_FAILURE;
+        }
+    }
+
+    printf("%016" PRIx64 "\n", t1ha2_atonce(word, length, T1HA2_SEED));
+    free(stdin_buffer);
+    return EXIT_SUCCESS;
+}