structs.c - tomo

(217 lines)
   1 // Metamethods for structs
   2 
   3 #include <stdint.h>
   4 #include <string.h>
   5 
   6 #include "bools.h"
   7 #include "metamethods.h"
   8 #include "siphash.h"
   9 #include "structs.h"
  10 #include "text.h"
  11 #include "util.h"
  12 
  13 #ifdef __GNUC__
  14 #pragma GCC diagnostic push
  15 #pragma GCC diagnostic ignored "-Wstack-protector"
  16 #endif
  17 PUREFUNC public uint64_t Struct$hash(const void *obj, const TypeInfo_t *type) {
  18     if (type->StructInfo.num_fields == 0) return 0;
  19 
  20     if (type->StructInfo.num_fields == 1) return generic_hash(obj, type->StructInfo.fields[0].type);
  21 
  22     uint64_t field_hashes[type->StructInfo.num_fields];
  23     ptrdiff_t byte_offset = 0;
  24     ptrdiff_t bit_offset = 0;
  25     for (int i = 0; i < type->StructInfo.num_fields; i++) {
  26         NamedType_t field = type->StructInfo.fields[i];
  27         if (field.type == &Bool$info) {
  28             bool b = ((*(char *)(obj + byte_offset)) >> bit_offset) & 0x1;
  29             field_hashes[i] = (uint32_t)b;
  30             bit_offset += 1;
  31             if (bit_offset >= 8) {
  32                 byte_offset += 1;
  33                 bit_offset = 0;
  34             }
  35         } else {
  36             if (bit_offset > 0) {
  37                 byte_offset += 1;
  38                 bit_offset = 0;
  39             }
  40             if (field.type->align && byte_offset % field.type->align > 0)
  41                 byte_offset += field.type->align - (byte_offset % field.type->align);
  42             field_hashes[i] = generic_hash(obj + byte_offset, field.type);
  43             byte_offset += field.type->size;
  44         }
  45     }
  46     return siphash24((void *)field_hashes, sizeof(field_hashes));
  47 }
  48 #ifdef __GNUC__
  49 #pragma GCC diagnostic pop
  50 #endif
  51 
  52 PUREFUNC public uint64_t PackedData$hash(const void *obj, const TypeInfo_t *type) {
  53     if (type->StructInfo.num_fields == 0) return 0;
  54 
  55     return siphash24(obj, (size_t)type->size);
  56 }
  57 
  58 PUREFUNC public int32_t Struct$compare(const void *x, const void *y, const TypeInfo_t *type) {
  59     if (x == y) return 0;
  60 
  61     ptrdiff_t byte_offset = 0;
  62     ptrdiff_t bit_offset = 0;
  63     for (int i = 0; i < type->StructInfo.num_fields; i++) {
  64         NamedType_t field = type->StructInfo.fields[i];
  65         if (field.type == &Bool$info) {
  66             bool bx = ((*(char *)(x + byte_offset)) >> bit_offset) & 0x1;
  67             bool by = ((*(char *)(y + byte_offset)) >> bit_offset) & 0x1;
  68             if (bx != by) return (int32_t)bx - (int32_t)by;
  69             bit_offset += 1;
  70             if (bit_offset >= 8) {
  71                 byte_offset += 1;
  72                 bit_offset = 0;
  73             }
  74         } else {
  75             if (bit_offset > 0) {
  76                 byte_offset += 1;
  77                 bit_offset = 0;
  78             }
  79             if (field.type->align && byte_offset % field.type->align > 0)
  80                 byte_offset += field.type->align - (byte_offset % field.type->align);
  81             int32_t cmp = generic_compare(x + byte_offset, y + byte_offset, field.type);
  82             if (cmp != 0) return cmp;
  83             byte_offset += field.type->size;
  84         }
  85     }
  86     return 0;
  87 }
  88 
  89 PUREFUNC public bool Struct$equal(const void *x, const void *y, const TypeInfo_t *type) {
  90     if (x == y) return true;
  91 
  92     ptrdiff_t byte_offset = 0;
  93     ptrdiff_t bit_offset = 0;
  94     for (int i = 0; i < type->StructInfo.num_fields; i++) {
  95         NamedType_t field = type->StructInfo.fields[i];
  96         if (field.type == &Bool$info) {
  97             bool bx = ((*(char *)(x + byte_offset)) >> bit_offset) & 0x1;
  98             bool by = ((*(char *)(y + byte_offset)) >> bit_offset) & 0x1;
  99             if (bx != by) return false;
 100             bit_offset += 1;
 101             if (bit_offset >= 8) {
 102                 byte_offset += 1;
 103                 bit_offset = 0;
 104             }
 105         } else {
 106             if (bit_offset > 0) {
 107                 byte_offset += 1;
 108                 bit_offset = 0;
 109             }
 110             if (field.type->align && byte_offset % field.type->align > 0)
 111                 byte_offset += field.type->align - (byte_offset % field.type->align);
 112             if (!generic_equal(x + byte_offset, y + byte_offset, field.type)) return false;
 113             byte_offset += field.type->size;
 114         }
 115     }
 116     return true;
 117 }
 118 
 119 PUREFUNC public bool PackedData$equal(const void *x, const void *y, const TypeInfo_t *type) {
 120     if (x == y) return true;
 121     return (memcmp(x, y, (size_t)type->size) == 0);
 122 }
 123 
 124 PUREFUNC public Text_t Struct$as_text(const void *obj, bool colorize, const TypeInfo_t *type) {
 125     if (!obj) return Text$from_str(type->StructInfo.name);
 126 
 127     Text_t name = Text$from_str(type->StructInfo.name);
 128     if (type->StructInfo.is_secret || type->StructInfo.is_opaque) {
 129         return colorize ? Text$concat(Text("\x1b[0;1m"), name, Text("\x1b[m(...)")) : Text$concat(name, Text("(...)"));
 130     }
 131 
 132     Text_t text = colorize ? Text$concat(Text("\x1b[0;1m"), name, Text("\x1b[m(")) : Text$concat(name, Text("("));
 133     ptrdiff_t byte_offset = 0;
 134     ptrdiff_t bit_offset = 0;
 135     for (int i = 0; i < type->StructInfo.num_fields; i++) {
 136         NamedType_t field = type->StructInfo.fields[i];
 137         if (i > 0) text = Text$concat(text, Text(", "));
 138 
 139         if (type->StructInfo.num_fields > 1) text = Text$concat(text, Text$from_str(field.name), Text("="));
 140 
 141         if (field.type == &Bool$info) {
 142             bool b = ((*(char *)(obj + byte_offset)) >> bit_offset) & 0x1;
 143             text = Text$concat(
 144                 text, Text$from_str(colorize ? (b ? "\x1b[35myes\x1b[m" : "\x1b[35mno\x1b[m") : (b ? "yes" : "no")));
 145             bit_offset += 1;
 146             if (bit_offset >= 8) {
 147                 byte_offset += 1;
 148                 bit_offset = 0;
 149             }
 150         } else {
 151             if (bit_offset > 0) {
 152                 byte_offset += 1;
 153                 bit_offset = 0;
 154             }
 155             if (field.type->align && byte_offset % field.type->align > 0)
 156                 byte_offset += field.type->align - (byte_offset % field.type->align);
 157             text = Text$concat(text, generic_as_text(obj + byte_offset, colorize, field.type));
 158             byte_offset += field.type->size;
 159         }
 160     }
 161     return Text$concat(text, Text(")"));
 162 }
 163 
 164 public
 165 
 166 void Struct$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) {
 167     ptrdiff_t byte_offset = 0;
 168     ptrdiff_t bit_offset = 0;
 169     for (int i = 0; i < type->StructInfo.num_fields; i++) {
 170         NamedType_t field = type->StructInfo.fields[i];
 171         if (field.type == &Bool$info) {
 172             bool b = ((*(char *)(obj + byte_offset)) >> bit_offset) & 0x1;
 173             fputc((int)b, out);
 174             bit_offset += 1;
 175             if (bit_offset >= 8) {
 176                 byte_offset += 1;
 177                 bit_offset = 0;
 178             }
 179         } else {
 180             if (bit_offset > 0) {
 181                 byte_offset += 1;
 182                 bit_offset = 0;
 183             }
 184             if (field.type->align && byte_offset % field.type->align > 0)
 185                 byte_offset += field.type->align - (byte_offset % field.type->align);
 186             _serialize(obj + byte_offset, out, pointers, field.type);
 187             byte_offset += field.type->size;
 188         }
 189     }
 190 }
 191 
 192 public
 193 void Struct$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type) {
 194     ptrdiff_t byte_offset = 0;
 195     ptrdiff_t bit_offset = 0;
 196     for (int i = 0; i < type->StructInfo.num_fields; i++) {
 197         NamedType_t field = type->StructInfo.fields[i];
 198         if (field.type == &Bool$info) {
 199             bool b = (bool)fgetc(in);
 200             *(char *)(outval + byte_offset) |= (b << bit_offset);
 201             bit_offset += 1;
 202             if (bit_offset >= 8) {
 203                 byte_offset += 1;
 204                 bit_offset = 0;
 205             }
 206         } else {
 207             if (bit_offset > 0) {
 208                 byte_offset += 1;
 209                 bit_offset = 0;
 210             }
 211             if (field.type->align && byte_offset % field.type->align > 0)
 212                 byte_offset += field.type->align - (byte_offset % field.type->align);
 213             _deserialize(in, outval + byte_offset, pointers, field.type);
 214             byte_offset += field.type->size;
 215         }
 216     }
 217 }