implement SipHash

crone/core/core.c

···
 
 #include "ptr_list.h"
 #include "list.h"
+#include "hash.h"
 

crone/core/hash.h

···
+
+/* SipHash magic numbers */
+const uint64_t magic_number_0 = 0x736f6d6570736575;
+const uint64_t magic_number_1 = 0x646f72616e646f6d;
+const uint64_t magic_number_2 = 0x6c7967656e657261;
+const uint64_t magic_number_3 = 0x7465646279746573;
+
+/* insecurely stored keys bc nobody's trying to hashdos my interpreter */
+const uint64_t key_0 = 0x0706050403020100;//0xdeadbeefdeadbeef;
+const uint64_t key_1 = 0x0f0e0d0c0b0a0908;//acdc1234f0069420;
+
+const uint64_t init_v0 = key_0 ^ magic_number_0;
+const uint64_t init_v1 = key_1 ^ magic_number_1;
+const uint64_t init_v2 = key_0 ^ magic_number_2;
+const uint64_t init_v3 = key_1 ^ magic_number_3;
+
+const uint32_t compress_rounds = 2;
+const uint32_t finalize_rounds = 4;
+
+#define ROTL(x, r) ((x << r) | (x >> (64 - r)))
+#define ROTR(x, r) ((x >> r) | (x << (64 - r)))
+
+hash calculate_hash(string s) {
+    uint8_t b = s.length % 256;
+    uint64_t v0 = init_v0;
+    uint64_t v1 = init_v1;
+    uint64_t v2 = init_v2;
+    uint64_t v3 = init_v3;
+
+    fprintf(stderr, " %lx %lx %lx %lx \n", v0, v1, v2, v3);
+
+    size_t position = 0;
+    while (s.length - position > 7) {
+        uint64_t m =
+            ((uint64_t)s.data[position]) |
+            ((uint64_t)s.data[position+1] << 8) |
+            ((uint64_t)s.data[position+2] << 16) |
+            ((uint64_t)s.data[position+3] << 24) |
+            ((uint64_t)s.data[position+4] << 32) |
+            ((uint64_t)s.data[position+5] << 40) |
+            ((uint64_t)s.data[position+6] << 48) |
+            ((uint64_t)s.data[position+7] << 56);
+
+        v3 ^= m;
+        fprintf(stderr, " %lx %lx %lx %lx \n", v0, v1, v2, v3);
+
+        for (int round = 0; round < compress_rounds; ++round) {
+            // SipRound, matching formatting of specification
+            v0 += v1;            v2 += v3;
+            v1 = ROTL(v1, 13);   v3 = ROTL(v3, 16);
+            v1 ^= v0;            v3 ^= v2;
+            v0 = ROTL(v0, 32);
+            v2 += v1;            v0 += v3;
+            v1 = ROTL(v1, 17);   v3 = ROTL(v3, 21);
+            v1 ^= v2;            v3 ^= v0;
+            v2 = ROTL(v2, 32);
+        }
+        fprintf(stderr, " %lx %lx %lx %lx \n", v0, v1, v2, v3);
+
+        v0 ^= m;
+
+        fprintf(stderr, " %lx %lx %lx %lx \n", v0, v1, v2, v3);
+
+        position += 8;
+    }
+
+    uint64_t m = ((uint64_t)b << 56);
+    size_t byte = 0;
+    while (s.length - position > byte) {
+        m |= ((uint64_t)s.data[position+byte] << (8*byte));
+        ++byte;
+    }
+
+    v3 ^= m;
+
+    for (int round = 0; round < compress_rounds; ++round) {
+        // SipRound, matching formatting of specification
+        v0 += v1;            v2 += v3;
+        v1 = ROTL(v1, 13);   v3 = ROTL(v3, 16);
+        v1 ^= v0;            v3 ^= v2;
+        v0 = ROTL(v0, 32);
+        v2 += v1;            v0 += v3;
+        v1 = ROTL(v1, 17);   v3 = ROTL(v3, 21);
+        v1 ^= v2;            v3 ^= v0;
+        v2 = ROTL(v2, 32);
+    }
+
+    v0 ^= m;
+
+    v2 ^= (uint64_t)0xff;
+
+    fprintf(stderr, " %lx %lx %lx %lx \n", v0, v1, v2, v3);
+
+    for (int round = 0; round < finalize_rounds; ++round) {
+        // SipRound, matching formatting of specification
+        v0 += v1;            v2 += v3;
+        v1 = ROTL(v1, 13);   v3 = ROTL(v3, 16);
+        v1 ^= v0;            v3 ^= v2;
+        v0 = ROTL(v0, 32);
+        v2 += v1;            v0 += v3;
+        v1 = ROTL(v1, 17);   v3 = ROTL(v3, 21);
+        v1 ^= v2;            v3 ^= v0;
+        v2 = ROTL(v2, 32);
+    }
+
+    fprintf(stderr, " %lx %lx %lx %lx \n", v0, v1, v2, v3);
+
+    fprintf(stderr, " %lx \n", v0 ^ v1 ^ v2 ^ v3);
+
+    return v0 ^ v1 ^ v2 ^ v3;
+}
+
+// TODO maybe-more-performant version ingesting one u8 at a time
+

crone/interface/core.h

···
 
+#include <stdint.h>
+
+#include "core/sane_string.h"
 #include "core/ptr_list.h"
 #include "core/list.h"
 #include "core/dev.h"
-
-typedef struct string {
-    char *data;
-    size_t length;
-} string;
+#include "core/hash.h"
 

crone/interface/core/hash.h

···
+
+typedef uint64_t hash;
+
+hash calculate_hash(string s);
+

crone/interface/core/sane_string.h

···
+
+typedef struct string {
+    uint8_t *data;
+    size_t length;
+} string;
+

crone/lang/interpreter.c

···
 #include <core.h>
 
 #define STATES(OP) \
-    OP(INVALID) \
     OP(OUTER_SPACE) \
     OP(TERM) \
+    OP(PUNCTUATION) \
     OP(INNER_SPACE) \
-    OP(PUNCTUATION) \
     OP(BLOCK) \
+    OP(EXIT_BLOCK) \
+    OP(CUSTOM) \
 
 #define COMMA_SEPARATED(VALUE) VALUE,
 #define COMMA_SEPARATED_STRINGS(VALUE) #VALUE,
···
     STATES(COMMA_SEPARATED_STRINGS)
 };
 
-void print_substring(char *start, size_t length) {
+void print_substring(uint8_t *start, size_t length) {
     for (size_t i = 0; i < length; ++i) {
         if (start[i] == '\n') {
             fputc('\\', stderr);
···
 }
 
 typedef struct parse {
-    char *start;
+    uint8_t *start;
     size_t length;
-    parser_state parsed_as;
+    void *custom_data;
     list subparses;
+    parser_state parsed_as;
 } parse;
 
 const char *spaces = "                                            ";
···
     fprintf(stderr, "]\n");
 }
 
-void transition(list *l, parse *p, char *end_position, parser_state next_state) {
+void transition(list *l, parse *p, uint8_t *end_position, parser_state next_state) {
     p->length = (size_t)end_position - (size_t)(p->start);
     list_append(l,p);
     p->start = end_position;
···
         switch (current_parse.parsed_as) {
             case OUTER_SPACE:
                 if (_char == '}') {
-                    NEXT(INVALID);
+                    NEXT(EXIT_BLOCK);
                 } else if (_char == '{') {
                     NEXT(BLOCK);
                 } else if (_char == ';') {
···
                 } else if (_char == ';') {
                     NEXT(PUNCTUATION);
                 } else if (_char == '}') {
-                    NEXT(INVALID);
+                    NEXT(EXIT_BLOCK);
                 } else if (!isspace(_char)) {
                     NEXT(TERM);
                 }
···
                 if (isspace(_char)) {
                     NEXT(INNER_SPACE);
                 } else if (_char == '}') {
-                    NEXT(INVALID);
+                    NEXT(EXIT_BLOCK);
                 } else if (_char == '{') {
                     NEXT(BLOCK);
                 } else if (_char == ';') {
···
                 if (isspace(_char)) {
                     NEXT(OUTER_SPACE);
                 } else if (_char == '}') {
-                    NEXT(INVALID);
+                    NEXT(EXIT_BLOCK);
                 } else if (_char == '{') {
                     NEXT(BLOCK);
                 } else if (_char != ';') {
                     NEXT(TERM);
                 }
             break;
-            case INVALID:
+            case EXIT_BLOCK:
                 return parses;
+            break;
+            case CUSTOM:
+                CRASH("CUSTOM parser state encountered in non-custom context");
             break;
         }
     }
···
     }
 
     cleanup_parses(parses);
-}
 
-/*
-
-# general syntax:
-
-term prelude {
-    block
+    fprintf(stderr, "parse size = %lu\n", sizeof(parse));
 }
 
-or
-
-term prelude;
-
-# example:
-
-## code
-exposed void ptrs_cleanup(ptr_list list) {
-    free(list.data);
-}
-
-## parse
-term="exposed"
-prelude="void ptrs_cleanup(ptr_list list)"
-block="free(list.data);"
-
-
-*/
-
-

crone/lang/parseme.cr

···
 
-term0 term1 term2 term3 {
+term0 term1      term2 term3 {
     block block
 
     block {
···
 
 hex FF0000;
 
-no reason you {can't} keep writing after {a block};
+should i [add] alternate (forms) of "differentiated" {blocks} <and> punctuation?
+
+{
+
+    no reason you {can't} keep writing after {a block};
+
+    #=================================================#
+
+    but ideally the {
+        linter
+    }
+
+    would format it {
+        like this
+    }
+
+}
 
 extraneous punctuation;;;
 

program.c

···
 
 #include <crone.h>
 
+const uint8_t test_str[15] = {
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+    0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E
+};
+
 int main() {
+
+    string s = {
+        .data = (uint8_t*)test_str,
+        .length = 15
+    };
+
+    hash h = calculate_hash(s);
+
+    /* parser
     //int fileDesc = open("./crone/core/core.cr", O_RDONLY, 0);
     int fileDesc = open("./crone/lang/parseme.cr", O_RDONLY, 0);
 
···
     if (result == -1) {
         CRASH("bad munmap");
     }
+    */
 
 
-
-    /*
+    /* graphics
     window_handle window = window_getWindow();
 
     vulkan_handle vk = vulkan_init();